@cloudpdf/sdk 3.0.0-next.12 → 3.0.0-next.14

package/dist/cjs/api/types/DocAnnotationsList200ResponseAnnotationsItem.d.ts

@@ -658,6 +658,9 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
     }
     interface Polygon {
         subtype: "polygon";
+        intent?: DocAnnotationsList200ResponseAnnotationsItemPolygon.Intent | undefined;
+        measure?: CloudPDF.DocAnnotationsList200ResponseAnnotationsItemPolygonMeasure | undefined;
+        caption?: DocAnnotationsList200ResponseAnnotationsItemPolygon.Caption | undefined;
         ref: CloudPDF.DocAnnotationsList200ResponseAnnotationsItemPolygonRef;
         pageObjectNumber: number;
         index: number;
@@ -689,6 +692,21 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
         cloudyIntensity: number | null;
     }
     namespace DocAnnotationsList200ResponseAnnotationsItemPolygon {
+        const Intent: {
+            readonly PolygonCloud: "PolygonCloud";
+            readonly PolygonDimension: "PolygonDimension";
+        };
+        type Intent = (typeof Intent)[keyof typeof Intent];
+        interface Caption {
+            enabled: boolean;
+            center?: Caption.Center | undefined;
+        }
+        namespace Caption {
+            interface Center {
+                x: number;
+                y: number;
+            }
+        }
         const IdentityQuality: {
             readonly Durable: "durable";
             readonly Weak: "weak";
@@ -763,6 +781,9 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
     }
     interface Polyline {
         subtype: "polyline";
+        intent?: DocAnnotationsList200ResponseAnnotationsItemPolyline.Intent | undefined;
+        measure?: CloudPDF.DocAnnotationsList200ResponseAnnotationsItemPolylineMeasure | undefined;
+        caption?: DocAnnotationsList200ResponseAnnotationsItemPolyline.Caption | undefined;
         ref: CloudPDF.DocAnnotationsList200ResponseAnnotationsItemPolylineRef;
         pageObjectNumber: number;
         index: number;
@@ -794,6 +815,20 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
         lineEndings: DocAnnotationsList200ResponseAnnotationsItemPolyline.LineEndings;
     }
     namespace DocAnnotationsList200ResponseAnnotationsItemPolyline {
+        const Intent: {
+            readonly PolyLineDimension: "PolyLineDimension";
+        };
+        type Intent = (typeof Intent)[keyof typeof Intent];
+        interface Caption {
+            enabled: boolean;
+            center?: Caption.Center | undefined;
+        }
+        namespace Caption {
+            interface Center {
+                x: number;
+                y: number;
+            }
+        }
         const IdentityQuality: {
             readonly Durable: "durable";
             readonly Weak: "weak";
@@ -900,6 +935,10 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
     }
     interface Line {
         subtype: "line";
+        intent?: DocAnnotationsList200ResponseAnnotationsItemLine.Intent | undefined;
+        measure?: CloudPDF.DocAnnotationsList200ResponseAnnotationsItemLineMeasure | undefined;
+        caption?: DocAnnotationsList200ResponseAnnotationsItemLine.Caption | undefined;
+        leader?: DocAnnotationsList200ResponseAnnotationsItemLine.Leader | undefined;
         ref: CloudPDF.DocAnnotationsList200ResponseAnnotationsItemLineRef;
         pageObjectNumber: number;
         index: number;
@@ -931,6 +970,32 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
         rotation?: number | undefined;
     }
     namespace DocAnnotationsList200ResponseAnnotationsItemLine {
+        const Intent: {
+            readonly LineArrow: "LineArrow";
+            readonly LineDimension: "LineDimension";
+        };
+        type Intent = (typeof Intent)[keyof typeof Intent];
+        interface Caption {
+            enabled: boolean;
+            position?: Caption.Position | undefined;
+            offset?: Caption.Offset | undefined;
+        }
+        namespace Caption {
+            const Position: {
+                readonly Inline: "inline";
+                readonly Top: "top";
+            };
+            type Position = (typeof Position)[keyof typeof Position];
+            interface Offset {
+                along: number;
+                perpendicular: number;
+            }
+        }
+        interface Leader {
+            length: number;
+            extension?: number | undefined;
+            offset?: number | undefined;
+        }
         const IdentityQuality: {
             readonly Durable: "durable";
             readonly Weak: "weak";
@@ -1241,9 +1306,10 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
         updatedBy?: string | undefined;
         actions?: CloudPDF.PdfAnnotationActions | undefined;
         intent: DocAnnotationsList200ResponseAnnotationsItemFreeText.Intent;
-        fontFamily: DocAnnotationsList200ResponseAnnotationsItemFreeText.FontFamily;
+        fontFamily: string;
         fontSize: number;
         textAlign: DocAnnotationsList200ResponseAnnotationsItemFreeText.TextAlign;
+        richText: DocAnnotationsList200ResponseAnnotationsItemFreeText.RichText;
         color: DocAnnotationsList200ResponseAnnotationsItemFreeText.Color;
         fontColor?: DocAnnotationsList200ResponseAnnotationsItemFreeText.FontColor | undefined;
         interiorColor: DocAnnotationsList200ResponseAnnotationsItemFreeText.InteriorColor | null;
@@ -1310,29 +1376,140 @@ export declare namespace DocAnnotationsList200ResponseAnnotationsItem {
             readonly FreeTextCallout: "free-text-callout";
         };
         type Intent = (typeof Intent)[keyof typeof Intent];
-        const FontFamily: {
-            readonly Courier: "courier";
-            readonly CourierBold: "courier-bold";
-            readonly CourierBoldOblique: "courier-bold-oblique";
-            readonly CourierOblique: "courier-oblique";
-            readonly Helvetica: "helvetica";
-            readonly HelveticaBold: "helvetica-bold";
-            readonly HelveticaBoldOblique: "helvetica-bold-oblique";
-            readonly HelveticaOblique: "helvetica-oblique";
-            readonly TimesRoman: "times-roman";
-            readonly TimesBold: "times-bold";
-            readonly TimesBoldItalic: "times-bold-italic";
-            readonly TimesItalic: "times-italic";
-            readonly Symbol: "symbol";
-            readonly ZapfDingbats: "zapf-dingbats";
-        };
-        type FontFamily = (typeof FontFamily)[keyof typeof FontFamily];
         const TextAlign: {
             readonly Left: "left";
             readonly Center: "center";
             readonly Right: "right";
         };
         type TextAlign = (typeof TextAlign)[keyof typeof TextAlign];
+        interface RichText {
+            body: RichText.Body;
+            paragraphs: RichText.Paragraphs.Item[];
+        }
+        namespace RichText {
+            interface Body {
+                family: string;
+                weight: number;
+                italic: boolean;
+                size: number;
+                color: string;
+                decoration: Body.Decoration.Item[];
+                script: Body.Script;
+                letterSpacing: number;
+                horizontalScale: number;
+                unknown?: string | undefined;
+                align: Body.Align;
+                dir: Body.Dir;
+                lineHeight?: number | undefined;
+                margins?: Body.Margins | undefined;
+                textIndent?: number | undefined;
+            }
+            namespace Body {
+                type Decoration = Decoration.Item[];
+                namespace Decoration {
+                    const Item: {
+                        readonly Underline: "underline";
+                        readonly LineThrough: "line-through";
+                        readonly Word: "word";
+                    };
+                    type Item = (typeof Item)[keyof typeof Item];
+                }
+                const Script: {
+                    readonly Normal: "normal";
+                    readonly Sub: "sub";
+                    readonly Super: "super";
+                };
+                type Script = (typeof Script)[keyof typeof Script];
+                const Align: {
+                    readonly Left: "left";
+                    readonly Center: "center";
+                    readonly Right: "right";
+                    readonly Justify: "justify";
+                };
+                type Align = (typeof Align)[keyof typeof Align];
+                const Dir: {
+                    readonly Ltr: "ltr";
+                    readonly Rtl: "rtl";
+                };
+                type Dir = (typeof Dir)[keyof typeof Dir];
+                interface Margins {
+                    top: number;
+                    bottom: number;
+                    left: number;
+                    right: number;
+                }
+            }
+            type Paragraphs = Paragraphs.Item[];
+            namespace Paragraphs {
+                interface Item {
+                    align?: Item.Align | undefined;
+                    dir?: Item.Dir | undefined;
+                    lineHeight?: number | undefined;
+                    margins?: Item.Margins | undefined;
+                    textIndent?: number | undefined;
+                    unknown?: string | undefined;
+                    runs: Item.Runs.Item[];
+                }
+                namespace Item {
+                    const Align: {
+                        readonly Left: "left";
+                        readonly Center: "center";
+                        readonly Right: "right";
+                        readonly Justify: "justify";
+                    };
+                    type Align = (typeof Align)[keyof typeof Align];
+                    const Dir: {
+                        readonly Ltr: "ltr";
+                        readonly Rtl: "rtl";
+                    };
+                    type Dir = (typeof Dir)[keyof typeof Dir];
+                    interface Margins {
+                        top: number;
+                        bottom: number;
+                        left: number;
+                        right: number;
+                    }
+                    type Runs = Runs.Item[];
+                    namespace Runs {
+                        interface Item {
+                            text: string;
+                            style?: Item.Style | undefined;
+                        }
+                        namespace Item {
+                            interface Style {
+                                family?: string | undefined;
+                                weight?: number | undefined;
+                                italic?: boolean | undefined;
+                                size?: number | undefined;
+                                color?: string | undefined;
+                                decoration?: Style.Decoration.Item[] | undefined;
+                                script?: Style.Script | undefined;
+                                letterSpacing?: number | undefined;
+                                horizontalScale?: number | undefined;
+                                unknown?: string | undefined;
+                            }
+                            namespace Style {
+                                type Decoration = Decoration.Item[];
+                                namespace Decoration {
+                                    const Item: {
+                                        readonly Underline: "underline";
+                                        readonly LineThrough: "line-through";
+                                        readonly Word: "word";
+                                    };
+                                    type Item = (typeof Item)[keyof typeof Item];
+                                }
+                                const Script: {
+                                    readonly Normal: "normal";
+                                    readonly Sub: "sub";
+                                    readonly Super: "super";
+                                };
+                                type Script = (typeof Script)[keyof typeof Script];
+                            }
+                        }
+                    }
+                }
+            }
+        }
         interface Color {
             r: number;
             g: number;

package/dist/cjs/api/types/DocAnnotationsList200ResponseAnnotationsItem.js

@@ -195,6 +195,10 @@ var DocAnnotationsList200ResponseAnnotationsItem;
     })(DocAnnotationsList200ResponseAnnotationsItemSquare = DocAnnotationsList200ResponseAnnotationsItem.DocAnnotationsList200ResponseAnnotationsItemSquare || (DocAnnotationsList200ResponseAnnotationsItem.DocAnnotationsList200ResponseAnnotationsItemSquare = {}));
     let DocAnnotationsList200ResponseAnnotationsItemPolygon;
     (function (DocAnnotationsList200ResponseAnnotationsItemPolygon) {
+        DocAnnotationsList200ResponseAnnotationsItemPolygon.Intent = {
+            PolygonCloud: "PolygonCloud",
+            PolygonDimension: "PolygonDimension",
+        };
         DocAnnotationsList200ResponseAnnotationsItemPolygon.IdentityQuality = {
             Durable: "durable",
             Weak: "weak",
@@ -230,6 +234,9 @@ var DocAnnotationsList200ResponseAnnotationsItem;
     })(DocAnnotationsList200ResponseAnnotationsItemPolygon = DocAnnotationsList200ResponseAnnotationsItem.DocAnnotationsList200ResponseAnnotationsItemPolygon || (DocAnnotationsList200ResponseAnnotationsItem.DocAnnotationsList200ResponseAnnotationsItemPolygon = {}));
     let DocAnnotationsList200ResponseAnnotationsItemPolyline;
     (function (DocAnnotationsList200ResponseAnnotationsItemPolyline) {
+        DocAnnotationsList200ResponseAnnotationsItemPolyline.Intent = {
+            PolyLineDimension: "PolyLineDimension",
+        };
         DocAnnotationsList200ResponseAnnotationsItemPolyline.IdentityQuality = {
             Durable: "durable",
             Weak: "weak",
@@ -292,6 +299,17 @@ var DocAnnotationsList200ResponseAnnotationsItem;
     })(DocAnnotationsList200ResponseAnnotationsItemPolyline = DocAnnotationsList200ResponseAnnotationsItem.DocAnnotationsList200ResponseAnnotationsItemPolyline || (DocAnnotationsList200ResponseAnnotationsItem.DocAnnotationsList200ResponseAnnotationsItemPolyline = {}));
     let DocAnnotationsList200ResponseAnnotationsItemLine;
     (function (DocAnnotationsList200ResponseAnnotationsItemLine) {
+        DocAnnotationsList200ResponseAnnotationsItemLine.Intent = {
+            LineArrow: "LineArrow",
+            LineDimension: "LineDimension",
+        };
+        let Caption;
+        (function (Caption) {
+            Caption.Position = {
+                Inline: "inline",
+                Top: "top",
+            };
+        })(Caption = DocAnnotationsList200ResponseAnnotationsItemLine.Caption || (DocAnnotationsList200ResponseAnnotationsItemLine.Caption = {}));
         DocAnnotationsList200ResponseAnnotationsItemLine.IdentityQuality = {
             Durable: "durable",
             Weak: "weak",
@@ -451,27 +469,78 @@ var DocAnnotationsList200ResponseAnnotationsItem;
             FreeText: "free-text",
             FreeTextCallout: "free-text-callout",
         };
-        DocAnnotationsList200ResponseAnnotationsItemFreeText.FontFamily = {
-            Courier: "courier",
-            CourierBold: "courier-bold",
-            CourierBoldOblique: "courier-bold-oblique",
-            CourierOblique: "courier-oblique",
-            Helvetica: "helvetica",
-            HelveticaBold: "helvetica-bold",
-            HelveticaBoldOblique: "helvetica-bold-oblique",
-            HelveticaOblique: "helvetica-oblique",
-            TimesRoman: "times-roman",
-            TimesBold: "times-bold",
-            TimesBoldItalic: "times-bold-italic",
-            TimesItalic: "times-italic",
-            Symbol: "symbol",
-            ZapfDingbats: "zapf-dingbats",
-        };
         DocAnnotationsList200ResponseAnnotationsItemFreeText.TextAlign = {
             Left: "left",
             Center: "center",
             Right: "right",
         };
+        let RichText;
+        (function (RichText) {
+            let Body;
+            (function (Body) {
+                let Decoration;
+                (function (Decoration) {
+                    Decoration.Item = {
+                        Underline: "underline",
+                        LineThrough: "line-through",
+                        Word: "word",
+                    };
+                })(Decoration = Body.Decoration || (Body.Decoration = {}));
+                Body.Script = {
+                    Normal: "normal",
+                    Sub: "sub",
+                    Super: "super",
+                };
+                Body.Align = {
+                    Left: "left",
+                    Center: "center",
+                    Right: "right",
+                    Justify: "justify",
+                };
+                Body.Dir = {
+                    Ltr: "ltr",
+                    Rtl: "rtl",
+                };
+            })(Body = RichText.Body || (RichText.Body = {}));
+            let Paragraphs;
+            (function (Paragraphs) {
+                let Item;
+                (function (Item_1) {
+                    Item_1.Align = {
+                        Left: "left",
+                        Center: "center",
+                        Right: "right",
+                        Justify: "justify",
+                    };
+                    Item_1.Dir = {
+                        Ltr: "ltr",
+                        Rtl: "rtl",
+                    };
+                    let Runs;
+                    (function (Runs) {
+                        let Item;
+                        (function (Item_2) {
+                            let Style;
+                            (function (Style) {
+                                let Decoration;
+                                (function (Decoration) {
+                                    Decoration.Item = {
+                                        Underline: "underline",
+                                        LineThrough: "line-through",
+                                        Word: "word",
+                                    };
+                                })(Decoration = Style.Decoration || (Style.Decoration = {}));
+                                Style.Script = {
+                                    Normal: "normal",
+                                    Sub: "sub",
+                                    Super: "super",
+                                };
+                            })(Style = Item_2.Style || (Item_2.Style = {}));
+                        })(Item = Runs.Item || (Runs.Item = {}));
+                    })(Runs = Item_1.Runs || (Item_1.Runs = {}));
+                })(Item = Paragraphs.Item || (Paragraphs.Item = {}));
+            })(Paragraphs = RichText.Paragraphs || (RichText.Paragraphs = {}));
+        })(RichText = DocAnnotationsList200ResponseAnnotationsItemFreeText.RichText || (DocAnnotationsList200ResponseAnnotationsItemFreeText.RichText = {}));
         DocAnnotationsList200ResponseAnnotationsItemFreeText.BorderStyle = {
             Solid: "solid",
             Dashed: "dashed",

package/dist/cjs/api/types/DocAnnotationsList200ResponseAnnotationsItemLineMeasure.d.ts

@@ -0,0 +1,202 @@
+import type * as CloudPDF from "../index.js";
+export type DocAnnotationsList200ResponseAnnotationsItemLineMeasure = CloudPDF.DocAnnotationsList200ResponseAnnotationsItemLineMeasure.Rl | CloudPDF.DocAnnotationsList200ResponseAnnotationsItemLineMeasure.Geo | CloudPDF.DocAnnotationsList200ResponseAnnotationsItemLineMeasure.Unknown;
+export declare namespace DocAnnotationsList200ResponseAnnotationsItemLineMeasure {
+    interface Rl {
+        subtype: "RL";
+        ratio?: string | undefined;
+        x: DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl.X.Item[];
+        y?: DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl.Y.Item[] | undefined;
+        distance: DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl.Distance.Item[];
+        area: DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl.Area.Item[];
+        angle?: DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl.Angle.Item[] | undefined;
+        slope?: DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl.Slope.Item[] | undefined;
+        origin?: DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl.Origin | undefined;
+        cyx?: number | undefined;
+    }
+    namespace DocAnnotationsList200ResponseAnnotationsItemLineMeasureRl {
+        type X = X.Item[];
+        namespace X {
+            interface Item {
+                unit: string;
+                conversion?: number | undefined;
+                fraction?: Item.Fraction | undefined;
+                precision?: number | undefined;
+                fixed?: boolean | undefined;
+                thousands?: string | undefined;
+                decimal?: string | undefined;
+                prefixSpacing?: string | undefined;
+                suffixSpacing?: string | undefined;
+                labelPosition?: Item.LabelPosition | undefined;
+            }
+            namespace Item {
+                const Fraction: {
+                    readonly Decimal: "decimal";
+                    readonly Fraction: "fraction";
+                    readonly Round: "round";
+                    readonly Truncate: "truncate";
+                };
+                type Fraction = (typeof Fraction)[keyof typeof Fraction];
+                const LabelPosition: {
+                    readonly Suffix: "suffix";
+                    readonly Prefix: "prefix";
+                };
+                type LabelPosition = (typeof LabelPosition)[keyof typeof LabelPosition];
+            }
+        }
+        type Y = Y.Item[];
+        namespace Y {
+            interface Item {
+                unit: string;
+                conversion?: number | undefined;
+                fraction?: Item.Fraction | undefined;
+                precision?: number | undefined;
+                fixed?: boolean | undefined;
+                thousands?: string | undefined;
+                decimal?: string | undefined;
+                prefixSpacing?: string | undefined;
+                suffixSpacing?: string | undefined;
+                labelPosition?: Item.LabelPosition | undefined;
+            }
+            namespace Item {
+                const Fraction: {
+                    readonly Decimal: "decimal";
+                    readonly Fraction: "fraction";
+                    readonly Round: "round";
+                    readonly Truncate: "truncate";
+                };
+                type Fraction = (typeof Fraction)[keyof typeof Fraction];
+                const LabelPosition: {
+                    readonly Suffix: "suffix";
+                    readonly Prefix: "prefix";
+                };
+                type LabelPosition = (typeof LabelPosition)[keyof typeof LabelPosition];
+            }
+        }
+        type Distance = Distance.Item[];
+        namespace Distance {
+            interface Item {
+                unit: string;
+                conversion?: number | undefined;
+                fraction?: Item.Fraction | undefined;
+                precision?: number | undefined;
+                fixed?: boolean | undefined;
+                thousands?: string | undefined;
+                decimal?: string | undefined;
+                prefixSpacing?: string | undefined;
+                suffixSpacing?: string | undefined;
+                labelPosition?: Item.LabelPosition | undefined;
+            }
+            namespace Item {
+                const Fraction: {
+                    readonly Decimal: "decimal";
+                    readonly Fraction: "fraction";
+                    readonly Round: "round";
+                    readonly Truncate: "truncate";
+                };
+                type Fraction = (typeof Fraction)[keyof typeof Fraction];
+                const LabelPosition: {
+                    readonly Suffix: "suffix";
+                    readonly Prefix: "prefix";
+                };
+                type LabelPosition = (typeof LabelPosition)[keyof typeof LabelPosition];
+            }
+        }
+        type Area = Area.Item[];
+        namespace Area {
+            interface Item {
+                unit: string;
+                conversion?: number | undefined;
+                fraction?: Item.Fraction | undefined;
+                precision?: number | undefined;
+                fixed?: boolean | undefined;
+                thousands?: string | undefined;
+                decimal?: string | undefined;
+                prefixSpacing?: string | undefined;
+                suffixSpacing?: string | undefined;
+                labelPosition?: Item.LabelPosition | undefined;
+            }
+            namespace Item {
+                const Fraction: {
+                    readonly Decimal: "decimal";
+                    readonly Fraction: "fraction";
+                    readonly Round: "round";
+                    readonly Truncate: "truncate";
+                };
+                type Fraction = (typeof Fraction)[keyof typeof Fraction];
+                const LabelPosition: {
+                    readonly Suffix: "suffix";
+                    readonly Prefix: "prefix";
+                };
+                type LabelPosition = (typeof LabelPosition)[keyof typeof LabelPosition];
+            }
+        }
+        type Angle = Angle.Item[];
+        namespace Angle {
+            interface Item {
+                unit: string;
+                conversion?: number | undefined;
+                fraction?: Item.Fraction | undefined;
+                precision?: number | undefined;
+                fixed?: boolean | undefined;
+                thousands?: string | undefined;
+                decimal?: string | undefined;
+                prefixSpacing?: string | undefined;
+                suffixSpacing?: string | undefined;
+                labelPosition?: Item.LabelPosition | undefined;
+            }
+            namespace Item {
+                const Fraction: {
+                    readonly Decimal: "decimal";
+                    readonly Fraction: "fraction";
+                    readonly Round: "round";
+                    readonly Truncate: "truncate";
+                };
+                type Fraction = (typeof Fraction)[keyof typeof Fraction];
+                const LabelPosition: {
+                    readonly Suffix: "suffix";
+                    readonly Prefix: "prefix";
+                };
+                type LabelPosition = (typeof LabelPosition)[keyof typeof LabelPosition];
+            }
+        }
+        type Slope = Slope.Item[];
+        namespace Slope {
+            interface Item {
+                unit: string;
+                conversion?: number | undefined;
+                fraction?: Item.Fraction | undefined;
+                precision?: number | undefined;
+                fixed?: boolean | undefined;
+                thousands?: string | undefined;
+                decimal?: string | undefined;
+                prefixSpacing?: string | undefined;
+                suffixSpacing?: string | undefined;
+                labelPosition?: Item.LabelPosition | undefined;
+            }
+            namespace Item {
+                const Fraction: {
+                    readonly Decimal: "decimal";
+                    readonly Fraction: "fraction";
+                    readonly Round: "round";
+                    readonly Truncate: "truncate";
+                };
+                type Fraction = (typeof Fraction)[keyof typeof Fraction];
+                const LabelPosition: {
+                    readonly Suffix: "suffix";
+                    readonly Prefix: "prefix";
+                };
+                type LabelPosition = (typeof LabelPosition)[keyof typeof LabelPosition];
+            }
+        }
+        interface Origin {
+            x: number;
+            y: number;
+        }
+    }
+    interface Geo {
+        subtype: "GEO";
+    }
+    interface Unknown {
+        subtype: "unknown";
+    }
+}