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

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

@@ -0,0 +1,200 @@
+import type * as CloudPDF from "../index.js";
+export type AnnotationPatchLineMeasure = CloudPDF.AnnotationPatchLineMeasure.Rectilinear | CloudPDF.AnnotationPatchLineMeasure.Unknown;
+export declare namespace AnnotationPatchLineMeasure {
+    interface Rectilinear {
+        subtype: "rectilinear";
+        ratio?: string | undefined;
+        x: AnnotationPatchLineMeasureRectilinear.X.Item[];
+        y?: AnnotationPatchLineMeasureRectilinear.Y.Item[] | undefined;
+        distance: AnnotationPatchLineMeasureRectilinear.Distance.Item[];
+        area: AnnotationPatchLineMeasureRectilinear.Area.Item[];
+        angle?: AnnotationPatchLineMeasureRectilinear.Angle.Item[] | undefined;
+        slope?: AnnotationPatchLineMeasureRectilinear.Slope.Item[] | undefined;
+        origin?: AnnotationPatchLineMeasureRectilinear.Origin | undefined;
+        cyx?: number | undefined;
+    }
+    namespace AnnotationPatchLineMeasureRectilinear {
+        type X = X.Item[];
+        namespace X {
+            interface Item {
+                unit: string;
+                conversion: number;
+                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;
+                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;
+                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;
+                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;
+                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;
+                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 Unknown {
+        subtype: "unknown";
+        value: CloudPDF.AnnotationPatchLineMeasureUnknown;
+    }
+}

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

@@ -0,0 +1,106 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationPatchLineMeasure = void 0;
+var AnnotationPatchLineMeasure;
+(function (AnnotationPatchLineMeasure) {
+    let AnnotationPatchLineMeasureRectilinear;
+    (function (AnnotationPatchLineMeasureRectilinear) {
+        let X;
+        (function (X) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = X.Item || (X.Item = {}));
+        })(X = AnnotationPatchLineMeasureRectilinear.X || (AnnotationPatchLineMeasureRectilinear.X = {}));
+        let Y;
+        (function (Y) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Y.Item || (Y.Item = {}));
+        })(Y = AnnotationPatchLineMeasureRectilinear.Y || (AnnotationPatchLineMeasureRectilinear.Y = {}));
+        let Distance;
+        (function (Distance) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Distance.Item || (Distance.Item = {}));
+        })(Distance = AnnotationPatchLineMeasureRectilinear.Distance || (AnnotationPatchLineMeasureRectilinear.Distance = {}));
+        let Area;
+        (function (Area) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Area.Item || (Area.Item = {}));
+        })(Area = AnnotationPatchLineMeasureRectilinear.Area || (AnnotationPatchLineMeasureRectilinear.Area = {}));
+        let Angle;
+        (function (Angle) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Angle.Item || (Angle.Item = {}));
+        })(Angle = AnnotationPatchLineMeasureRectilinear.Angle || (AnnotationPatchLineMeasureRectilinear.Angle = {}));
+        let Slope;
+        (function (Slope) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Slope.Item || (Slope.Item = {}));
+        })(Slope = AnnotationPatchLineMeasureRectilinear.Slope || (AnnotationPatchLineMeasureRectilinear.Slope = {}));
+    })(AnnotationPatchLineMeasureRectilinear = AnnotationPatchLineMeasure.AnnotationPatchLineMeasureRectilinear || (AnnotationPatchLineMeasure.AnnotationPatchLineMeasureRectilinear = {}));
+})(AnnotationPatchLineMeasure || (exports.AnnotationPatchLineMeasure = AnnotationPatchLineMeasure = {}));

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

@@ -0,0 +1,10 @@
+import type * as CloudPDF from "../index.js";
+export type AnnotationPatchLineMeasureUnknown = CloudPDF.AnnotationPatchLineMeasureUnknown.Geospatial | CloudPDF.AnnotationPatchLineMeasureUnknown.Unknown;
+export declare namespace AnnotationPatchLineMeasureUnknown {
+    interface Geospatial {
+        subtype: "geospatial";
+    }
+    interface Unknown {
+        subtype: "unknown";
+    }
+}

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

@@ -0,0 +1,200 @@
+import type * as CloudPDF from "../index.js";
+export type AnnotationPatchPolygonMeasure = CloudPDF.AnnotationPatchPolygonMeasure.Rectilinear | CloudPDF.AnnotationPatchPolygonMeasure.Unknown;
+export declare namespace AnnotationPatchPolygonMeasure {
+    interface Rectilinear {
+        subtype: "rectilinear";
+        ratio?: string | undefined;
+        x: AnnotationPatchPolygonMeasureRectilinear.X.Item[];
+        y?: AnnotationPatchPolygonMeasureRectilinear.Y.Item[] | undefined;
+        distance: AnnotationPatchPolygonMeasureRectilinear.Distance.Item[];
+        area: AnnotationPatchPolygonMeasureRectilinear.Area.Item[];
+        angle?: AnnotationPatchPolygonMeasureRectilinear.Angle.Item[] | undefined;
+        slope?: AnnotationPatchPolygonMeasureRectilinear.Slope.Item[] | undefined;
+        origin?: AnnotationPatchPolygonMeasureRectilinear.Origin | undefined;
+        cyx?: number | undefined;
+    }
+    namespace AnnotationPatchPolygonMeasureRectilinear {
+        type X = X.Item[];
+        namespace X {
+            interface Item {
+                unit: string;
+                conversion: number;
+                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;
+                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;
+                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;
+                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;
+                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;
+                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 Unknown {
+        subtype: "unknown";
+        value: CloudPDF.AnnotationPatchPolygonMeasureUnknown;
+    }
+}

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

@@ -0,0 +1,106 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationPatchPolygonMeasure = void 0;
+var AnnotationPatchPolygonMeasure;
+(function (AnnotationPatchPolygonMeasure) {
+    let AnnotationPatchPolygonMeasureRectilinear;
+    (function (AnnotationPatchPolygonMeasureRectilinear) {
+        let X;
+        (function (X) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = X.Item || (X.Item = {}));
+        })(X = AnnotationPatchPolygonMeasureRectilinear.X || (AnnotationPatchPolygonMeasureRectilinear.X = {}));
+        let Y;
+        (function (Y) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Y.Item || (Y.Item = {}));
+        })(Y = AnnotationPatchPolygonMeasureRectilinear.Y || (AnnotationPatchPolygonMeasureRectilinear.Y = {}));
+        let Distance;
+        (function (Distance) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Distance.Item || (Distance.Item = {}));
+        })(Distance = AnnotationPatchPolygonMeasureRectilinear.Distance || (AnnotationPatchPolygonMeasureRectilinear.Distance = {}));
+        let Area;
+        (function (Area) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Area.Item || (Area.Item = {}));
+        })(Area = AnnotationPatchPolygonMeasureRectilinear.Area || (AnnotationPatchPolygonMeasureRectilinear.Area = {}));
+        let Angle;
+        (function (Angle) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Angle.Item || (Angle.Item = {}));
+        })(Angle = AnnotationPatchPolygonMeasureRectilinear.Angle || (AnnotationPatchPolygonMeasureRectilinear.Angle = {}));
+        let Slope;
+        (function (Slope) {
+            let Item;
+            (function (Item) {
+                Item.Fraction = {
+                    Decimal: "decimal",
+                    Fraction: "fraction",
+                    Round: "round",
+                    Truncate: "truncate",
+                };
+                Item.LabelPosition = {
+                    Suffix: "suffix",
+                    Prefix: "prefix",
+                };
+            })(Item = Slope.Item || (Slope.Item = {}));
+        })(Slope = AnnotationPatchPolygonMeasureRectilinear.Slope || (AnnotationPatchPolygonMeasureRectilinear.Slope = {}));
+    })(AnnotationPatchPolygonMeasureRectilinear = AnnotationPatchPolygonMeasure.AnnotationPatchPolygonMeasureRectilinear || (AnnotationPatchPolygonMeasure.AnnotationPatchPolygonMeasureRectilinear = {}));
+})(AnnotationPatchPolygonMeasure || (exports.AnnotationPatchPolygonMeasure = AnnotationPatchPolygonMeasure = {}));

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

@@ -0,0 +1,10 @@
+import type * as CloudPDF from "../index.js";
+export type AnnotationPatchPolygonMeasureUnknown = CloudPDF.AnnotationPatchPolygonMeasureUnknown.Geospatial | CloudPDF.AnnotationPatchPolygonMeasureUnknown.Unknown;
+export declare namespace AnnotationPatchPolygonMeasureUnknown {
+    interface Geospatial {
+        subtype: "geospatial";
+    }
+    interface Unknown {
+        subtype: "unknown";
+    }
+}