@cloudpdf/sdk 3.0.0-next.13 → 3.0.0-next.15

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

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

package/dist/cjs/api/types/AnnotationPatchPolylineMeasure.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.AnnotationPatchPolylineMeasure = void 0;
+var AnnotationPatchPolylineMeasure;
+(function (AnnotationPatchPolylineMeasure) {
+    let AnnotationPatchPolylineMeasureRectilinear;
+    (function (AnnotationPatchPolylineMeasureRectilinear) {
+        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 = AnnotationPatchPolylineMeasureRectilinear.X || (AnnotationPatchPolylineMeasureRectilinear.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 = AnnotationPatchPolylineMeasureRectilinear.Y || (AnnotationPatchPolylineMeasureRectilinear.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 = AnnotationPatchPolylineMeasureRectilinear.Distance || (AnnotationPatchPolylineMeasureRectilinear.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 = AnnotationPatchPolylineMeasureRectilinear.Area || (AnnotationPatchPolylineMeasureRectilinear.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 = AnnotationPatchPolylineMeasureRectilinear.Angle || (AnnotationPatchPolylineMeasureRectilinear.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 = AnnotationPatchPolylineMeasureRectilinear.Slope || (AnnotationPatchPolylineMeasureRectilinear.Slope = {}));
+    })(AnnotationPatchPolylineMeasureRectilinear = AnnotationPatchPolylineMeasure.AnnotationPatchPolylineMeasureRectilinear || (AnnotationPatchPolylineMeasure.AnnotationPatchPolylineMeasureRectilinear = {}));
+})(AnnotationPatchPolylineMeasure || (exports.AnnotationPatchPolylineMeasure = AnnotationPatchPolylineMeasure = {}));

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

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

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

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

package/dist/cjs/api/types/AnnotationPolygonMeasure.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.AnnotationPolygonMeasure = void 0;
+var AnnotationPolygonMeasure;
+(function (AnnotationPolygonMeasure) {
+    let AnnotationPolygonMeasureRectilinear;
+    (function (AnnotationPolygonMeasureRectilinear) {
+        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 = AnnotationPolygonMeasureRectilinear.X || (AnnotationPolygonMeasureRectilinear.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 = AnnotationPolygonMeasureRectilinear.Y || (AnnotationPolygonMeasureRectilinear.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 = AnnotationPolygonMeasureRectilinear.Distance || (AnnotationPolygonMeasureRectilinear.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 = AnnotationPolygonMeasureRectilinear.Area || (AnnotationPolygonMeasureRectilinear.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 = AnnotationPolygonMeasureRectilinear.Angle || (AnnotationPolygonMeasureRectilinear.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 = AnnotationPolygonMeasureRectilinear.Slope || (AnnotationPolygonMeasureRectilinear.Slope = {}));
+    })(AnnotationPolygonMeasureRectilinear = AnnotationPolygonMeasure.AnnotationPolygonMeasureRectilinear || (AnnotationPolygonMeasure.AnnotationPolygonMeasureRectilinear = {}));
+})(AnnotationPolygonMeasure || (exports.AnnotationPolygonMeasure = AnnotationPolygonMeasure = {}));