From cf407a9461c604fcd5988d84d1c1eba2e1c8936c Mon Sep 17 00:00:00 2001 From: cloudpdf-sdk-bot Date: Wed, 11 Nov 2026 23:32:03 +0000 Subject: [PATCH] chore: generate CloudPDF Java SDK 3.2.0 --- .fern/metadata.json | 4 +- build.gradle | 4 +- cloudpdf-generation.json | 8 +- .../java/api/AsyncCloudPDFClientBuilder.java | 2 +- src/main/java/api/CloudPDFClientBuilder.java | 2 +- src/main/java/api/core/ClientOptions.java | 2 +- src/main/java/api/types/ChangeItem.java | 116 +++++++ .../api/types/ChangeItemAnnotationsCopy.java | 252 ++++++++++++++ .../ChangeItemAnnotationsCopyDroppedItem.java | 175 ++++++++++ ...eItemAnnotationsCopyDroppedItemReason.java | 174 ++++++++++ .../ChangeItemAnnotationsCopyRefMapItem.java | 142 ++++++++ .../java/api/types/ChangeItemFormsCopy.java | 327 ++++++++++++++++++ .../types/ChangeItemFormsCopyDroppedItem.java | 238 +++++++++++++ .../ChangeItemFormsCopyDroppedItemReason.java | 119 +++++++ .../types/ChangeItemFormsCopyRefMapItem.java | 141 ++++++++ .../java/api/types/ChangeItemSkippedOp.java | 21 ++ src/main/java/api/types/ChangeOp.java | 116 +++++++ .../api/types/ChangeOpAnnotationsCopy.java | 191 ++++++++++ .../types/ChangeOpAnnotationsCopyOffset.java | 139 ++++++++ .../java/api/types/ChangeOpFormsCopy.java | 239 +++++++++++++ .../api/types/ChangeOpFormsCopyOffset.java | 139 ++++++++ 21 files changed, 2540 insertions(+), 11 deletions(-) create mode 100644 src/main/java/api/types/ChangeItemAnnotationsCopy.java create mode 100644 src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItem.java create mode 100644 src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItemReason.java create mode 100644 src/main/java/api/types/ChangeItemAnnotationsCopyRefMapItem.java create mode 100644 src/main/java/api/types/ChangeItemFormsCopy.java create mode 100644 src/main/java/api/types/ChangeItemFormsCopyDroppedItem.java create mode 100644 src/main/java/api/types/ChangeItemFormsCopyDroppedItemReason.java create mode 100644 src/main/java/api/types/ChangeItemFormsCopyRefMapItem.java create mode 100644 src/main/java/api/types/ChangeOpAnnotationsCopy.java create mode 100644 src/main/java/api/types/ChangeOpAnnotationsCopyOffset.java create mode 100644 src/main/java/api/types/ChangeOpFormsCopy.java create mode 100644 src/main/java/api/types/ChangeOpFormsCopyOffset.java diff --git a/.fern/metadata.json b/.fern/metadata.json index 5a68e21..ec024f1 100644 --- a/.fern/metadata.json +++ b/.fern/metadata.json @@ -10,9 +10,9 @@ "base-exception-class-name": "CloudPDFException", "base-api-exception-class-name": "CloudPDFApiException" }, - "originGitCommit": "37273d7d149f893255344f0f8e9ff7b2dfbc8057", + "originGitCommit": "e074ee8465006a168ff6d8cfa73928df13ae159c", "originGitCommitIsDirty": false, "invokedBy": "ci", - "requestedVersion": "3.1.0", + "requestedVersion": "3.2.0", "ciProvider": "github" } \ No newline at end of file diff --git a/build.gradle b/build.gradle index 24e608a..bc888d6 100644 --- a/build.gradle +++ b/build.gradle @@ -46,7 +46,7 @@ java { group = 'com.cloudpdf' -version = '3.1.0' +version = '3.2.0' jar { dependsOn(":generatePomFileForMavenPublication") @@ -73,7 +73,7 @@ publishing { maven(MavenPublication) { groupId = 'com.cloudpdf' artifactId = 'sdk' - version = '3.1.0' + version = '3.2.0' from components.java pom { name = 'CloudPDF' diff --git a/cloudpdf-generation.json b/cloudpdf-generation.json index f4c7526..5e52825 100644 --- a/cloudpdf-generation.json +++ b/cloudpdf-generation.json @@ -1,12 +1,12 @@ { "language": "java", - "canonicalVersion": "3.1.0", - "sdkVersion": "3.1.0", + "canonicalVersion": "3.2.0", + "sdkVersion": "3.2.0", "source": { "repository": "embedpdf/embed-pdf-viewer", "openapi": "cloudpdf/contract/openapi.json", - "openapiSha256": "5e62a5502b502635c63f989110a74f98a9f7f3f3a3696d6f1fccb4ea39e1efe3", - "gitCommit": "37273d7d149f893255344f0f8e9ff7b2dfbc8057", + "openapiSha256": "92b335b44d0957c70139f64ee3dd92e19d9d3a1452c90077002ed31dbddc3e7d", + "gitCommit": "e074ee8465006a168ff6d8cfa73928df13ae159c", "gitCommitIsDirty": false }, "fern": { diff --git a/src/main/java/api/AsyncCloudPDFClientBuilder.java b/src/main/java/api/AsyncCloudPDFClientBuilder.java index 04c559d..bf3d15c 100644 --- a/src/main/java/api/AsyncCloudPDFClientBuilder.java +++ b/src/main/java/api/AsyncCloudPDFClientBuilder.java @@ -26,7 +26,7 @@ public class AsyncCloudPDFClientBuilder { private String token = null; - private String embedPdfVersion = "3.1"; + private String embedPdfVersion = "3.2"; private Environment environment = Environment.SAAS; diff --git a/src/main/java/api/CloudPDFClientBuilder.java b/src/main/java/api/CloudPDFClientBuilder.java index a9183b2..01a7ca0 100644 --- a/src/main/java/api/CloudPDFClientBuilder.java +++ b/src/main/java/api/CloudPDFClientBuilder.java @@ -26,7 +26,7 @@ public class CloudPDFClientBuilder { private String token = null; - private String embedPdfVersion = "3.1"; + private String embedPdfVersion = "3.2"; private Environment environment = Environment.SAAS; diff --git a/src/main/java/api/core/ClientOptions.java b/src/main/java/api/core/ClientOptions.java index 1c0f858..0d28422 100644 --- a/src/main/java/api/core/ClientOptions.java +++ b/src/main/java/api/core/ClientOptions.java @@ -49,7 +49,7 @@ private ClientOptions( { put("X-Fern-Language", "JAVA"); put("X-Fern-SDK-Name", "com.cloudpdf:sdk"); - put("X-Fern-SDK-Version", "3.1.0"); + put("X-Fern-SDK-Version", "3.2.0"); } }); this.headerSuppliers = headerSuppliers; diff --git a/src/main/java/api/types/ChangeItem.java b/src/main/java/api/types/ChangeItem.java index eef8479..55863c9 100644 --- a/src/main/java/api/types/ChangeItem.java +++ b/src/main/java/api/types/ChangeItem.java @@ -46,6 +46,10 @@ public static ChangeItem annotationsReorder(ChangeItemAnnotationsReorder value) return new ChangeItem(new AnnotationsReorderValue(value)); } + public static ChangeItem annotationsCopy(ChangeItemAnnotationsCopy value) { + return new ChangeItem(new AnnotationsCopyValue(value)); + } + public static ChangeItem annotationsRestore(ChangeItemAnnotationsRestore value) { return new ChangeItem(new AnnotationsRestoreValue(value)); } @@ -70,6 +74,10 @@ public static ChangeItem formsCreate(ChangeItemFormsCreate value) { return new ChangeItem(new FormsCreateValue(value)); } + public static ChangeItem formsCopy(ChangeItemFormsCopy value) { + return new ChangeItem(new FormsCopyValue(value)); + } + public static ChangeItem formsUpdate(ChangeItemFormsUpdate value) { return new ChangeItem(new FormsUpdateValue(value)); } @@ -206,6 +214,10 @@ public boolean isAnnotationsReorder() { return value instanceof AnnotationsReorderValue; } + public boolean isAnnotationsCopy() { + return value instanceof AnnotationsCopyValue; + } + public boolean isAnnotationsRestore() { return value instanceof AnnotationsRestoreValue; } @@ -230,6 +242,10 @@ public boolean isFormsCreate() { return value instanceof FormsCreateValue; } + public boolean isFormsCopy() { + return value instanceof FormsCopyValue; + } + public boolean isFormsUpdate() { return value instanceof FormsUpdateValue; } @@ -385,6 +401,13 @@ public Optional getAnnotationsReorder() { return Optional.empty(); } + public Optional getAnnotationsCopy() { + if (isAnnotationsCopy()) { + return Optional.of(((AnnotationsCopyValue) value).value); + } + return Optional.empty(); + } + public Optional getAnnotationsRestore() { if (isAnnotationsRestore()) { return Optional.of(((AnnotationsRestoreValue) value).value); @@ -427,6 +450,13 @@ public Optional getFormsCreate() { return Optional.empty(); } + public Optional getFormsCopy() { + if (isFormsCopy()) { + return Optional.of(((FormsCopyValue) value).value); + } + return Optional.empty(); + } + public Optional getFormsUpdate() { if (isFormsUpdate()) { return Optional.of(((FormsUpdateValue) value).value); @@ -669,6 +699,8 @@ public interface Visitor { T visitAnnotationsReorder(ChangeItemAnnotationsReorder annotationsReorder); + T visitAnnotationsCopy(ChangeItemAnnotationsCopy annotationsCopy); + T visitAnnotationsRestore(ChangeItemAnnotationsRestore annotationsRestore); T visitFormsSetValue(ChangeItemFormsSetValue formsSetValue); @@ -681,6 +713,8 @@ public interface Visitor { T visitFormsCreate(ChangeItemFormsCreate formsCreate); + T visitFormsCopy(ChangeItemFormsCopy formsCopy); + T visitFormsUpdate(ChangeItemFormsUpdate formsUpdate); T visitFormsDelete(ChangeItemFormsDelete formsDelete); @@ -749,12 +783,14 @@ public interface Visitor { @JsonSubTypes.Type(AnnotationsUpdateValue.class), @JsonSubTypes.Type(AnnotationsDeleteValue.class), @JsonSubTypes.Type(AnnotationsReorderValue.class), + @JsonSubTypes.Type(AnnotationsCopyValue.class), @JsonSubTypes.Type(AnnotationsRestoreValue.class), @JsonSubTypes.Type(FormsSetValueValue.class), @JsonSubTypes.Type(FormsSetDisplayValue.class), @JsonSubTypes.Type(FormsSetAppearanceTextValue.class), @JsonSubTypes.Type(FormsResetValue.class), @JsonSubTypes.Type(FormsCreateValue.class), + @JsonSubTypes.Type(FormsCopyValue.class), @JsonSubTypes.Type(FormsUpdateValue.class), @JsonSubTypes.Type(FormsDeleteValue.class), @JsonSubTypes.Type(FormsRestoreValue.class), @@ -990,6 +1026,46 @@ public String toString() { } } + @JsonTypeName("annotations.copy") + @JsonIgnoreProperties("type") + private static final class AnnotationsCopyValue implements Value { + @JsonUnwrapped + @JsonIgnoreProperties(value = "type", allowSetters = true) + private ChangeItemAnnotationsCopy value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private AnnotationsCopyValue() {} + + private AnnotationsCopyValue(ChangeItemAnnotationsCopy value) { + this.value = value; + } + + @java.lang.Override + public T visit(Visitor visitor) { + return visitor.visitAnnotationsCopy(value); + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof AnnotationsCopyValue && equalTo((AnnotationsCopyValue) other); + } + + private boolean equalTo(AnnotationsCopyValue other) { + return value.equals(other.value); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.value); + } + + @java.lang.Override + public String toString() { + return "ChangeItem{" + "value: " + value + "}"; + } + } + @JsonTypeName("annotations.restore") @JsonIgnoreProperties("type") private static final class AnnotationsRestoreValue implements Value { @@ -1230,6 +1306,46 @@ public String toString() { } } + @JsonTypeName("forms.copy") + @JsonIgnoreProperties("type") + private static final class FormsCopyValue implements Value { + @JsonUnwrapped + @JsonIgnoreProperties(value = "type", allowSetters = true) + private ChangeItemFormsCopy value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private FormsCopyValue() {} + + private FormsCopyValue(ChangeItemFormsCopy value) { + this.value = value; + } + + @java.lang.Override + public T visit(Visitor visitor) { + return visitor.visitFormsCopy(value); + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof FormsCopyValue && equalTo((FormsCopyValue) other); + } + + private boolean equalTo(FormsCopyValue other) { + return value.equals(other.value); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.value); + } + + @java.lang.Override + public String toString() { + return "ChangeItem{" + "value: " + value + "}"; + } + } + @JsonTypeName("forms.update") @JsonIgnoreProperties("type") private static final class FormsUpdateValue implements Value { diff --git a/src/main/java/api/types/ChangeItemAnnotationsCopy.java b/src/main/java/api/types/ChangeItemAnnotationsCopy.java new file mode 100644 index 0000000..350a4ee --- /dev/null +++ b/src/main/java/api/types/ChangeItemAnnotationsCopy.java @@ -0,0 +1,252 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import org.jetbrains.annotations.NotNull; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeItemAnnotationsCopy.Builder.class) +public final class ChangeItemAnnotationsCopy { + private final List annotations; + + private final List refMap; + + private final List dropped; + + private final AnnotationMutationMeta meta; + + private final Map additionalProperties; + + private ChangeItemAnnotationsCopy( + List annotations, + List refMap, + List dropped, + AnnotationMutationMeta meta, + Map additionalProperties) { + this.annotations = annotations; + this.refMap = refMap; + this.dropped = dropped; + this.meta = meta; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("annotations") + public List getAnnotations() { + return annotations; + } + + @JsonProperty("refMap") + public List getRefMap() { + return refMap; + } + + @JsonProperty("dropped") + public List getDropped() { + return dropped; + } + + @JsonProperty("meta") + public AnnotationMutationMeta getMeta() { + return meta; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeItemAnnotationsCopy && equalTo((ChangeItemAnnotationsCopy) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeItemAnnotationsCopy other) { + return annotations.equals(other.annotations) + && refMap.equals(other.refMap) + && dropped.equals(other.dropped) + && meta.equals(other.meta); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.annotations, this.refMap, this.dropped, this.meta); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static MetaStage builder() { + return new Builder(); + } + + public interface MetaStage { + _FinalStage meta(@NotNull AnnotationMutationMeta meta); + + Builder from(ChangeItemAnnotationsCopy other); + } + + public interface _FinalStage { + ChangeItemAnnotationsCopy build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + + _FinalStage annotations(List annotations); + + _FinalStage addAnnotations(Annotation annotations); + + _FinalStage addAllAnnotations(List annotations); + + _FinalStage refMap(List refMap); + + _FinalStage addRefMap(ChangeItemAnnotationsCopyRefMapItem refMap); + + _FinalStage addAllRefMap(List refMap); + + _FinalStage dropped(List dropped); + + _FinalStage addDropped(ChangeItemAnnotationsCopyDroppedItem dropped); + + _FinalStage addAllDropped(List dropped); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements MetaStage, _FinalStage { + private AnnotationMutationMeta meta; + + private List dropped = new ArrayList<>(); + + private List refMap = new ArrayList<>(); + + private List annotations = new ArrayList<>(); + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeItemAnnotationsCopy other) { + annotations(other.getAnnotations()); + refMap(other.getRefMap()); + dropped(other.getDropped()); + meta(other.getMeta()); + return this; + } + + @java.lang.Override + @JsonSetter("meta") + public _FinalStage meta(@NotNull AnnotationMutationMeta meta) { + this.meta = Objects.requireNonNull(meta, "meta must not be null"); + return this; + } + + @java.lang.Override + public _FinalStage addAllDropped(List dropped) { + if (dropped != null) { + this.dropped.addAll(dropped); + } + return this; + } + + @java.lang.Override + public _FinalStage addDropped(ChangeItemAnnotationsCopyDroppedItem dropped) { + this.dropped.add(dropped); + return this; + } + + @java.lang.Override + @JsonSetter(value = "dropped", nulls = Nulls.SKIP) + public _FinalStage dropped(List dropped) { + this.dropped.clear(); + if (dropped != null) { + this.dropped.addAll(dropped); + } + return this; + } + + @java.lang.Override + public _FinalStage addAllRefMap(List refMap) { + if (refMap != null) { + this.refMap.addAll(refMap); + } + return this; + } + + @java.lang.Override + public _FinalStage addRefMap(ChangeItemAnnotationsCopyRefMapItem refMap) { + this.refMap.add(refMap); + return this; + } + + @java.lang.Override + @JsonSetter(value = "refMap", nulls = Nulls.SKIP) + public _FinalStage refMap(List refMap) { + this.refMap.clear(); + if (refMap != null) { + this.refMap.addAll(refMap); + } + return this; + } + + @java.lang.Override + public _FinalStage addAllAnnotations(List annotations) { + if (annotations != null) { + this.annotations.addAll(annotations); + } + return this; + } + + @java.lang.Override + public _FinalStage addAnnotations(Annotation annotations) { + this.annotations.add(annotations); + return this; + } + + @java.lang.Override + @JsonSetter(value = "annotations", nulls = Nulls.SKIP) + public _FinalStage annotations(List annotations) { + this.annotations.clear(); + if (annotations != null) { + this.annotations.addAll(annotations); + } + return this; + } + + @java.lang.Override + public ChangeItemAnnotationsCopy build() { + return new ChangeItemAnnotationsCopy(annotations, refMap, dropped, meta, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItem.java b/src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItem.java new file mode 100644 index 0000000..8c0a27f --- /dev/null +++ b/src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItem.java @@ -0,0 +1,175 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import org.jetbrains.annotations.NotNull; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeItemAnnotationsCopyDroppedItem.Builder.class) +public final class ChangeItemAnnotationsCopyDroppedItem { + private final AnnotationRef ref; + + private final Optional field; + + private final ChangeItemAnnotationsCopyDroppedItemReason reason; + + private final Map additionalProperties; + + private ChangeItemAnnotationsCopyDroppedItem( + AnnotationRef ref, + Optional field, + ChangeItemAnnotationsCopyDroppedItemReason reason, + Map additionalProperties) { + this.ref = ref; + this.field = field; + this.reason = reason; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("ref") + public AnnotationRef getRef() { + return ref; + } + + @JsonProperty("field") + public Optional getField() { + return field; + } + + @JsonProperty("reason") + public ChangeItemAnnotationsCopyDroppedItemReason getReason() { + return reason; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeItemAnnotationsCopyDroppedItem + && equalTo((ChangeItemAnnotationsCopyDroppedItem) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeItemAnnotationsCopyDroppedItem other) { + return ref.equals(other.ref) && field.equals(other.field) && reason.equals(other.reason); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.ref, this.field, this.reason); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static RefStage builder() { + return new Builder(); + } + + public interface RefStage { + ReasonStage ref(@NotNull AnnotationRef ref); + + Builder from(ChangeItemAnnotationsCopyDroppedItem other); + } + + public interface ReasonStage { + _FinalStage reason(@NotNull ChangeItemAnnotationsCopyDroppedItemReason reason); + } + + public interface _FinalStage { + ChangeItemAnnotationsCopyDroppedItem build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + + _FinalStage field(Optional field); + + _FinalStage field(String field); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements RefStage, ReasonStage, _FinalStage { + private AnnotationRef ref; + + private ChangeItemAnnotationsCopyDroppedItemReason reason; + + private Optional field = Optional.empty(); + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeItemAnnotationsCopyDroppedItem other) { + ref(other.getRef()); + field(other.getField()); + reason(other.getReason()); + return this; + } + + @java.lang.Override + @JsonSetter("ref") + public ReasonStage ref(@NotNull AnnotationRef ref) { + this.ref = Objects.requireNonNull(ref, "ref must not be null"); + return this; + } + + @java.lang.Override + @JsonSetter("reason") + public _FinalStage reason(@NotNull ChangeItemAnnotationsCopyDroppedItemReason reason) { + this.reason = Objects.requireNonNull(reason, "reason must not be null"); + return this; + } + + @java.lang.Override + public _FinalStage field(String field) { + this.field = Optional.ofNullable(field); + return this; + } + + @java.lang.Override + @JsonSetter(value = "field", nulls = Nulls.SKIP) + public _FinalStage field(Optional field) { + this.field = field; + return this; + } + + @java.lang.Override + public ChangeItemAnnotationsCopyDroppedItem build() { + return new ChangeItemAnnotationsCopyDroppedItem(ref, field, reason, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItemReason.java b/src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItemReason.java new file mode 100644 index 0000000..f8d09ab --- /dev/null +++ b/src/main/java/api/types/ChangeItemAnnotationsCopyDroppedItemReason.java @@ -0,0 +1,174 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; + +public final class ChangeItemAnnotationsCopyDroppedItemReason { + public static final ChangeItemAnnotationsCopyDroppedItemReason UNSUPPORTED_KIND = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.UNSUPPORTED_KIND, "unsupported-kind"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason UNKNOWN_MEASURE = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.UNKNOWN_MEASURE, "unknown-measure"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason WIDGET = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.WIDGET, "widget"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason UNSUPPORTED_VALUE = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.UNSUPPORTED_VALUE, "unsupported-value"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason POPUP_TAKEN = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.POPUP_TAKEN, "popup-taken"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason PARENT_DROPPED = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.PARENT_DROPPED, "parent-dropped"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason UNSUPPORTED_ACTION = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.UNSUPPORTED_ACTION, "unsupported-action"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason GEOSPATIAL = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.GEOSPATIAL, "geospatial"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason NAME_CONFLICT = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.NAME_CONFLICT, "name-conflict"); + + public static final ChangeItemAnnotationsCopyDroppedItemReason PARENT_MISSING = + new ChangeItemAnnotationsCopyDroppedItemReason(Value.PARENT_MISSING, "parent-missing"); + + private final Value value; + + private final String string; + + ChangeItemAnnotationsCopyDroppedItemReason(Value value, String string) { + this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; + } + + @java.lang.Override + @JsonValue + public String toString() { + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof ChangeItemAnnotationsCopyDroppedItemReason + && this.string.equals(((ChangeItemAnnotationsCopyDroppedItemReason) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case UNSUPPORTED_KIND: + return visitor.visitUnsupportedKind(); + case UNKNOWN_MEASURE: + return visitor.visitUnknownMeasure(); + case WIDGET: + return visitor.visitWidget(); + case UNSUPPORTED_VALUE: + return visitor.visitUnsupportedValue(); + case POPUP_TAKEN: + return visitor.visitPopupTaken(); + case PARENT_DROPPED: + return visitor.visitParentDropped(); + case UNSUPPORTED_ACTION: + return visitor.visitUnsupportedAction(); + case GEOSPATIAL: + return visitor.visitGeospatial(); + case NAME_CONFLICT: + return visitor.visitNameConflict(); + case PARENT_MISSING: + return visitor.visitParentMissing(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ChangeItemAnnotationsCopyDroppedItemReason valueOf(String value) { + switch (value) { + case "unsupported-kind": + return UNSUPPORTED_KIND; + case "unknown-measure": + return UNKNOWN_MEASURE; + case "widget": + return WIDGET; + case "unsupported-value": + return UNSUPPORTED_VALUE; + case "popup-taken": + return POPUP_TAKEN; + case "parent-dropped": + return PARENT_DROPPED; + case "unsupported-action": + return UNSUPPORTED_ACTION; + case "geospatial": + return GEOSPATIAL; + case "name-conflict": + return NAME_CONFLICT; + case "parent-missing": + return PARENT_MISSING; + default: + return new ChangeItemAnnotationsCopyDroppedItemReason(Value.UNKNOWN, value); + } + } + + public enum Value { + UNSUPPORTED_KIND, + + WIDGET, + + GEOSPATIAL, + + UNKNOWN_MEASURE, + + UNSUPPORTED_ACTION, + + UNSUPPORTED_VALUE, + + NAME_CONFLICT, + + PARENT_DROPPED, + + PARENT_MISSING, + + POPUP_TAKEN, + + UNKNOWN + } + + public interface Visitor { + T visitUnsupportedKind(); + + T visitWidget(); + + T visitGeospatial(); + + T visitUnknownMeasure(); + + T visitUnsupportedAction(); + + T visitUnsupportedValue(); + + T visitNameConflict(); + + T visitParentDropped(); + + T visitParentMissing(); + + T visitPopupTaken(); + + T visitUnknown(String unknownType); + } +} diff --git a/src/main/java/api/types/ChangeItemAnnotationsCopyRefMapItem.java b/src/main/java/api/types/ChangeItemAnnotationsCopyRefMapItem.java new file mode 100644 index 0000000..2ab2910 --- /dev/null +++ b/src/main/java/api/types/ChangeItemAnnotationsCopyRefMapItem.java @@ -0,0 +1,142 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import org.jetbrains.annotations.NotNull; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeItemAnnotationsCopyRefMapItem.Builder.class) +public final class ChangeItemAnnotationsCopyRefMapItem { + private final AnnotationRef from; + + private final AnnotationRef to; + + private final Map additionalProperties; + + private ChangeItemAnnotationsCopyRefMapItem( + AnnotationRef from, AnnotationRef to, Map additionalProperties) { + this.from = from; + this.to = to; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("from") + public AnnotationRef getFrom() { + return from; + } + + @JsonProperty("to") + public AnnotationRef getTo() { + return to; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeItemAnnotationsCopyRefMapItem + && equalTo((ChangeItemAnnotationsCopyRefMapItem) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeItemAnnotationsCopyRefMapItem other) { + return from.equals(other.from) && to.equals(other.to); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.from, this.to); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static FromStage builder() { + return new Builder(); + } + + public interface FromStage { + ToStage from(@NotNull AnnotationRef from); + + Builder from(ChangeItemAnnotationsCopyRefMapItem other); + } + + public interface ToStage { + _FinalStage to(@NotNull AnnotationRef to); + } + + public interface _FinalStage { + ChangeItemAnnotationsCopyRefMapItem build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements FromStage, ToStage, _FinalStage { + private AnnotationRef from; + + private AnnotationRef to; + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeItemAnnotationsCopyRefMapItem other) { + from(other.getFrom()); + to(other.getTo()); + return this; + } + + @java.lang.Override + @JsonSetter("from") + public ToStage from(@NotNull AnnotationRef from) { + this.from = Objects.requireNonNull(from, "from must not be null"); + return this; + } + + @java.lang.Override + @JsonSetter("to") + public _FinalStage to(@NotNull AnnotationRef to) { + this.to = Objects.requireNonNull(to, "to must not be null"); + return this; + } + + @java.lang.Override + public ChangeItemAnnotationsCopyRefMapItem build() { + return new ChangeItemAnnotationsCopyRefMapItem(from, to, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeItemFormsCopy.java b/src/main/java/api/types/ChangeItemFormsCopy.java new file mode 100644 index 0000000..63d1c89 --- /dev/null +++ b/src/main/java/api/types/ChangeItemFormsCopy.java @@ -0,0 +1,327 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import org.jetbrains.annotations.NotNull; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeItemFormsCopy.Builder.class) +public final class ChangeItemFormsCopy { + private final List fields; + + private final List widgets; + + private final List refMap; + + private final List dropped; + + private final Optional> calculationOrder; + + private final FormMutationMeta meta; + + private final Map additionalProperties; + + private ChangeItemFormsCopy( + List fields, + List widgets, + List refMap, + List dropped, + Optional> calculationOrder, + FormMutationMeta meta, + Map additionalProperties) { + this.fields = fields; + this.widgets = widgets; + this.refMap = refMap; + this.dropped = dropped; + this.calculationOrder = calculationOrder; + this.meta = meta; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("fields") + public List getFields() { + return fields; + } + + @JsonProperty("widgets") + public List getWidgets() { + return widgets; + } + + @JsonProperty("refMap") + public List getRefMap() { + return refMap; + } + + @JsonProperty("dropped") + public List getDropped() { + return dropped; + } + + @JsonProperty("calculationOrder") + public Optional> getCalculationOrder() { + return calculationOrder; + } + + @JsonProperty("meta") + public FormMutationMeta getMeta() { + return meta; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeItemFormsCopy && equalTo((ChangeItemFormsCopy) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeItemFormsCopy other) { + return fields.equals(other.fields) + && widgets.equals(other.widgets) + && refMap.equals(other.refMap) + && dropped.equals(other.dropped) + && calculationOrder.equals(other.calculationOrder) + && meta.equals(other.meta); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.fields, this.widgets, this.refMap, this.dropped, this.calculationOrder, this.meta); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static MetaStage builder() { + return new Builder(); + } + + public interface MetaStage { + _FinalStage meta(@NotNull FormMutationMeta meta); + + Builder from(ChangeItemFormsCopy other); + } + + public interface _FinalStage { + ChangeItemFormsCopy build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + + _FinalStage fields(List fields); + + _FinalStage addFields(FormField fields); + + _FinalStage addAllFields(List fields); + + _FinalStage widgets(List widgets); + + _FinalStage addWidgets(WidgetAnnotation widgets); + + _FinalStage addAllWidgets(List widgets); + + _FinalStage refMap(List refMap); + + _FinalStage addRefMap(ChangeItemFormsCopyRefMapItem refMap); + + _FinalStage addAllRefMap(List refMap); + + _FinalStage dropped(List dropped); + + _FinalStage addDropped(ChangeItemFormsCopyDroppedItem dropped); + + _FinalStage addAllDropped(List dropped); + + _FinalStage calculationOrder(Optional> calculationOrder); + + _FinalStage calculationOrder(List calculationOrder); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements MetaStage, _FinalStage { + private FormMutationMeta meta; + + private Optional> calculationOrder = Optional.empty(); + + private List dropped = new ArrayList<>(); + + private List refMap = new ArrayList<>(); + + private List widgets = new ArrayList<>(); + + private List fields = new ArrayList<>(); + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeItemFormsCopy other) { + fields(other.getFields()); + widgets(other.getWidgets()); + refMap(other.getRefMap()); + dropped(other.getDropped()); + calculationOrder(other.getCalculationOrder()); + meta(other.getMeta()); + return this; + } + + @java.lang.Override + @JsonSetter("meta") + public _FinalStage meta(@NotNull FormMutationMeta meta) { + this.meta = Objects.requireNonNull(meta, "meta must not be null"); + return this; + } + + @java.lang.Override + public _FinalStage calculationOrder(List calculationOrder) { + this.calculationOrder = Optional.ofNullable(calculationOrder); + return this; + } + + @java.lang.Override + @JsonSetter(value = "calculationOrder", nulls = Nulls.SKIP) + public _FinalStage calculationOrder(Optional> calculationOrder) { + this.calculationOrder = calculationOrder; + return this; + } + + @java.lang.Override + public _FinalStage addAllDropped(List dropped) { + if (dropped != null) { + this.dropped.addAll(dropped); + } + return this; + } + + @java.lang.Override + public _FinalStage addDropped(ChangeItemFormsCopyDroppedItem dropped) { + this.dropped.add(dropped); + return this; + } + + @java.lang.Override + @JsonSetter(value = "dropped", nulls = Nulls.SKIP) + public _FinalStage dropped(List dropped) { + this.dropped.clear(); + if (dropped != null) { + this.dropped.addAll(dropped); + } + return this; + } + + @java.lang.Override + public _FinalStage addAllRefMap(List refMap) { + if (refMap != null) { + this.refMap.addAll(refMap); + } + return this; + } + + @java.lang.Override + public _FinalStage addRefMap(ChangeItemFormsCopyRefMapItem refMap) { + this.refMap.add(refMap); + return this; + } + + @java.lang.Override + @JsonSetter(value = "refMap", nulls = Nulls.SKIP) + public _FinalStage refMap(List refMap) { + this.refMap.clear(); + if (refMap != null) { + this.refMap.addAll(refMap); + } + return this; + } + + @java.lang.Override + public _FinalStage addAllWidgets(List widgets) { + if (widgets != null) { + this.widgets.addAll(widgets); + } + return this; + } + + @java.lang.Override + public _FinalStage addWidgets(WidgetAnnotation widgets) { + this.widgets.add(widgets); + return this; + } + + @java.lang.Override + @JsonSetter(value = "widgets", nulls = Nulls.SKIP) + public _FinalStage widgets(List widgets) { + this.widgets.clear(); + if (widgets != null) { + this.widgets.addAll(widgets); + } + return this; + } + + @java.lang.Override + public _FinalStage addAllFields(List fields) { + if (fields != null) { + this.fields.addAll(fields); + } + return this; + } + + @java.lang.Override + public _FinalStage addFields(FormField fields) { + this.fields.add(fields); + return this; + } + + @java.lang.Override + @JsonSetter(value = "fields", nulls = Nulls.SKIP) + public _FinalStage fields(List fields) { + this.fields.clear(); + if (fields != null) { + this.fields.addAll(fields); + } + return this; + } + + @java.lang.Override + public ChangeItemFormsCopy build() { + return new ChangeItemFormsCopy( + fields, widgets, refMap, dropped, calculationOrder, meta, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeItemFormsCopyDroppedItem.java b/src/main/java/api/types/ChangeItemFormsCopyDroppedItem.java new file mode 100644 index 0000000..a5d987d --- /dev/null +++ b/src/main/java/api/types/ChangeItemFormsCopyDroppedItem.java @@ -0,0 +1,238 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.Nullable; +import com.cloudpdf.api.core.NullableNonemptyFilter; +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import org.jetbrains.annotations.NotNull; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeItemFormsCopyDroppedItem.Builder.class) +public final class ChangeItemFormsCopyDroppedItem { + private final Optional ref; + + private final Optional widget; + + private final Optional field; + + private final ChangeItemFormsCopyDroppedItemReason reason; + + private final Map additionalProperties; + + private ChangeItemFormsCopyDroppedItem( + Optional ref, + Optional widget, + Optional field, + ChangeItemFormsCopyDroppedItemReason reason, + Map additionalProperties) { + this.ref = ref; + this.widget = widget; + this.field = field; + this.reason = reason; + this.additionalProperties = additionalProperties; + } + + @JsonIgnore + public Optional getRef() { + if (ref == null) { + return Optional.empty(); + } + return ref; + } + + @JsonProperty("widget") + public Optional getWidget() { + return widget; + } + + @JsonProperty("field") + public Optional getField() { + return field; + } + + @JsonProperty("reason") + public ChangeItemFormsCopyDroppedItemReason getReason() { + return reason; + } + + @JsonInclude(value = JsonInclude.Include.CUSTOM, valueFilter = NullableNonemptyFilter.class) + @JsonProperty("ref") + private Optional _getRef() { + return ref; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeItemFormsCopyDroppedItem && equalTo((ChangeItemFormsCopyDroppedItem) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeItemFormsCopyDroppedItem other) { + return ref.equals(other.ref) + && widget.equals(other.widget) + && field.equals(other.field) + && reason.equals(other.reason); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.ref, this.widget, this.field, this.reason); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static ReasonStage builder() { + return new Builder(); + } + + public interface ReasonStage { + _FinalStage reason(@NotNull ChangeItemFormsCopyDroppedItemReason reason); + + Builder from(ChangeItemFormsCopyDroppedItem other); + } + + public interface _FinalStage { + ChangeItemFormsCopyDroppedItem build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + + _FinalStage ref(Optional ref); + + _FinalStage ref(FormFieldRef ref); + + _FinalStage ref(Nullable ref); + + _FinalStage widget(Optional widget); + + _FinalStage widget(AnnotationRef widget); + + _FinalStage field(Optional field); + + _FinalStage field(String field); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements ReasonStage, _FinalStage { + private ChangeItemFormsCopyDroppedItemReason reason; + + private Optional field = Optional.empty(); + + private Optional widget = Optional.empty(); + + private Optional ref = Optional.empty(); + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeItemFormsCopyDroppedItem other) { + ref(other.getRef()); + widget(other.getWidget()); + field(other.getField()); + reason(other.getReason()); + return this; + } + + @java.lang.Override + @JsonSetter("reason") + public _FinalStage reason(@NotNull ChangeItemFormsCopyDroppedItemReason reason) { + this.reason = Objects.requireNonNull(reason, "reason must not be null"); + return this; + } + + @java.lang.Override + public _FinalStage field(String field) { + this.field = Optional.ofNullable(field); + return this; + } + + @java.lang.Override + @JsonSetter(value = "field", nulls = Nulls.SKIP) + public _FinalStage field(Optional field) { + this.field = field; + return this; + } + + @java.lang.Override + public _FinalStage widget(AnnotationRef widget) { + this.widget = Optional.ofNullable(widget); + return this; + } + + @java.lang.Override + @JsonSetter(value = "widget", nulls = Nulls.SKIP) + public _FinalStage widget(Optional widget) { + this.widget = widget; + return this; + } + + @java.lang.Override + public _FinalStage ref(Nullable ref) { + if (ref.isNull()) { + this.ref = null; + } else if (ref.isEmpty()) { + this.ref = Optional.empty(); + } else { + this.ref = Optional.of(ref.get()); + } + return this; + } + + @java.lang.Override + public _FinalStage ref(FormFieldRef ref) { + this.ref = Optional.ofNullable(ref); + return this; + } + + @java.lang.Override + @JsonSetter(value = "ref", nulls = Nulls.SKIP) + public _FinalStage ref(Optional ref) { + this.ref = ref; + return this; + } + + @java.lang.Override + public ChangeItemFormsCopyDroppedItem build() { + return new ChangeItemFormsCopyDroppedItem(ref, widget, field, reason, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeItemFormsCopyDroppedItemReason.java b/src/main/java/api/types/ChangeItemFormsCopyDroppedItemReason.java new file mode 100644 index 0000000..741f8b6 --- /dev/null +++ b/src/main/java/api/types/ChangeItemFormsCopyDroppedItemReason.java @@ -0,0 +1,119 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonValue; + +public final class ChangeItemFormsCopyDroppedItemReason { + public static final ChangeItemFormsCopyDroppedItemReason UNSUPPORTED_KIND = + new ChangeItemFormsCopyDroppedItemReason(Value.UNSUPPORTED_KIND, "unsupported-kind"); + + public static final ChangeItemFormsCopyDroppedItemReason NO_FIELD = + new ChangeItemFormsCopyDroppedItemReason(Value.NO_FIELD, "no-field"); + + public static final ChangeItemFormsCopyDroppedItemReason UNSUPPORTED_ACTION = + new ChangeItemFormsCopyDroppedItemReason(Value.UNSUPPORTED_ACTION, "unsupported-action"); + + public static final ChangeItemFormsCopyDroppedItemReason SCRIPT_NOT_ALLOWED = + new ChangeItemFormsCopyDroppedItemReason(Value.SCRIPT_NOT_ALLOWED, "script-not-allowed"); + + public static final ChangeItemFormsCopyDroppedItemReason NAME_CONFLICT = + new ChangeItemFormsCopyDroppedItemReason(Value.NAME_CONFLICT, "name-conflict"); + + private final Value value; + + private final String string; + + ChangeItemFormsCopyDroppedItemReason(Value value, String string) { + this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; + } + + @java.lang.Override + @JsonValue + public String toString() { + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof ChangeItemFormsCopyDroppedItemReason + && this.string.equals(((ChangeItemFormsCopyDroppedItemReason) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case UNSUPPORTED_KIND: + return visitor.visitUnsupportedKind(); + case NO_FIELD: + return visitor.visitNoField(); + case UNSUPPORTED_ACTION: + return visitor.visitUnsupportedAction(); + case SCRIPT_NOT_ALLOWED: + return visitor.visitScriptNotAllowed(); + case NAME_CONFLICT: + return visitor.visitNameConflict(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ChangeItemFormsCopyDroppedItemReason valueOf(String value) { + switch (value) { + case "unsupported-kind": + return UNSUPPORTED_KIND; + case "no-field": + return NO_FIELD; + case "unsupported-action": + return UNSUPPORTED_ACTION; + case "script-not-allowed": + return SCRIPT_NOT_ALLOWED; + case "name-conflict": + return NAME_CONFLICT; + default: + return new ChangeItemFormsCopyDroppedItemReason(Value.UNKNOWN, value); + } + } + + public enum Value { + NAME_CONFLICT, + + NO_FIELD, + + UNSUPPORTED_KIND, + + SCRIPT_NOT_ALLOWED, + + UNSUPPORTED_ACTION, + + UNKNOWN + } + + public interface Visitor { + T visitNameConflict(); + + T visitNoField(); + + T visitUnsupportedKind(); + + T visitScriptNotAllowed(); + + T visitUnsupportedAction(); + + T visitUnknown(String unknownType); + } +} diff --git a/src/main/java/api/types/ChangeItemFormsCopyRefMapItem.java b/src/main/java/api/types/ChangeItemFormsCopyRefMapItem.java new file mode 100644 index 0000000..31b106b --- /dev/null +++ b/src/main/java/api/types/ChangeItemFormsCopyRefMapItem.java @@ -0,0 +1,141 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import org.jetbrains.annotations.NotNull; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeItemFormsCopyRefMapItem.Builder.class) +public final class ChangeItemFormsCopyRefMapItem { + private final FormFieldRef from; + + private final FormFieldRef to; + + private final Map additionalProperties; + + private ChangeItemFormsCopyRefMapItem( + FormFieldRef from, FormFieldRef to, Map additionalProperties) { + this.from = from; + this.to = to; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("from") + public FormFieldRef getFrom() { + return from; + } + + @JsonProperty("to") + public FormFieldRef getTo() { + return to; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeItemFormsCopyRefMapItem && equalTo((ChangeItemFormsCopyRefMapItem) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeItemFormsCopyRefMapItem other) { + return from.equals(other.from) && to.equals(other.to); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.from, this.to); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static FromStage builder() { + return new Builder(); + } + + public interface FromStage { + ToStage from(@NotNull FormFieldRef from); + + Builder from(ChangeItemFormsCopyRefMapItem other); + } + + public interface ToStage { + _FinalStage to(@NotNull FormFieldRef to); + } + + public interface _FinalStage { + ChangeItemFormsCopyRefMapItem build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements FromStage, ToStage, _FinalStage { + private FormFieldRef from; + + private FormFieldRef to; + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeItemFormsCopyRefMapItem other) { + from(other.getFrom()); + to(other.getTo()); + return this; + } + + @java.lang.Override + @JsonSetter("from") + public ToStage from(@NotNull FormFieldRef from) { + this.from = Objects.requireNonNull(from, "from must not be null"); + return this; + } + + @java.lang.Override + @JsonSetter("to") + public _FinalStage to(@NotNull FormFieldRef to) { + this.to = Objects.requireNonNull(to, "to must not be null"); + return this; + } + + @java.lang.Override + public ChangeItemFormsCopyRefMapItem build() { + return new ChangeItemFormsCopyRefMapItem(from, to, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeItemSkippedOp.java b/src/main/java/api/types/ChangeItemSkippedOp.java index f274674..adb15f4 100644 --- a/src/main/java/api/types/ChangeItemSkippedOp.java +++ b/src/main/java/api/types/ChangeItemSkippedOp.java @@ -18,6 +18,9 @@ public final class ChangeItemSkippedOp { public static final ChangeItemSkippedOp PAGES_RESTORE = new ChangeItemSkippedOp(Value.PAGES_RESTORE, "pages.restore"); + public static final ChangeItemSkippedOp ANNOTATIONS_COPY = + new ChangeItemSkippedOp(Value.ANNOTATIONS_COPY, "annotations.copy"); + public static final ChangeItemSkippedOp OUTLINE_MOVE = new ChangeItemSkippedOp(Value.OUTLINE_MOVE, "outline.move"); public static final ChangeItemSkippedOp OUTLINE_UPDATE = @@ -73,6 +76,8 @@ public final class ChangeItemSkippedOp { public static final ChangeItemSkippedOp FORMS_REMOVE_WIDGET = new ChangeItemSkippedOp(Value.FORMS_REMOVE_WIDGET, "forms.removeWidget"); + public static final ChangeItemSkippedOp FORMS_COPY = new ChangeItemSkippedOp(Value.FORMS_COPY, "forms.copy"); + public static final ChangeItemSkippedOp OUTLINE_RESTORE = new ChangeItemSkippedOp(Value.OUTLINE_RESTORE, "outline.restore"); @@ -155,6 +160,8 @@ public T visit(Visitor visitor) { return visitor.visitFormsDelete(); case PAGES_RESTORE: return visitor.visitPagesRestore(); + case ANNOTATIONS_COPY: + return visitor.visitAnnotationsCopy(); case OUTLINE_MOVE: return visitor.visitOutlineMove(); case OUTLINE_UPDATE: @@ -195,6 +202,8 @@ public T visit(Visitor visitor) { return visitor.visitAttachmentsCreate(); case FORMS_REMOVE_WIDGET: return visitor.visitFormsRemoveWidget(); + case FORMS_COPY: + return visitor.visitFormsCopy(); case OUTLINE_RESTORE: return visitor.visitOutlineRestore(); case FORMS_UPDATE: @@ -242,6 +251,8 @@ public static ChangeItemSkippedOp valueOf(String value) { return FORMS_DELETE; case "pages.restore": return PAGES_RESTORE; + case "annotations.copy": + return ANNOTATIONS_COPY; case "outline.move": return OUTLINE_MOVE; case "outline.update": @@ -282,6 +293,8 @@ public static ChangeItemSkippedOp valueOf(String value) { return ATTACHMENTS_CREATE; case "forms.removeWidget": return FORMS_REMOVE_WIDGET; + case "forms.copy": + return FORMS_COPY; case "outline.restore": return OUTLINE_RESTORE; case "forms.update": @@ -326,6 +339,8 @@ public enum Value { ANNOTATIONS_REORDER, + ANNOTATIONS_COPY, + FORMS_SET_VALUE, FORMS_SET_DISPLAY, @@ -336,6 +351,8 @@ public enum Value { FORMS_CREATE, + FORMS_COPY, + FORMS_UPDATE, FORMS_DELETE, @@ -408,6 +425,8 @@ public interface Visitor { T visitAnnotationsReorder(); + T visitAnnotationsCopy(); + T visitFormsSetValue(); T visitFormsSetDisplay(); @@ -418,6 +437,8 @@ public interface Visitor { T visitFormsCreate(); + T visitFormsCopy(); + T visitFormsUpdate(); T visitFormsDelete(); diff --git a/src/main/java/api/types/ChangeOp.java b/src/main/java/api/types/ChangeOp.java index d521b5c..c22f59c 100644 --- a/src/main/java/api/types/ChangeOp.java +++ b/src/main/java/api/types/ChangeOp.java @@ -42,6 +42,10 @@ public static ChangeOp annotationsReorder(ChangeOpAnnotationsReorder value) { return new ChangeOp(new AnnotationsReorderValue(value)); } + public static ChangeOp annotationsCopy(ChangeOpAnnotationsCopy value) { + return new ChangeOp(new AnnotationsCopyValue(value)); + } + public static ChangeOp formsSetValue(ChangeOpFormsSetValue value) { return new ChangeOp(new FormsSetValueValue(value)); } @@ -62,6 +66,10 @@ public static ChangeOp formsCreate(ChangeOpFormsCreate value) { return new ChangeOp(new FormsCreateValue(value)); } + public static ChangeOp formsCopy(ChangeOpFormsCopy value) { + return new ChangeOp(new FormsCopyValue(value)); + } + public static ChangeOp formsUpdate(ChangeOpFormsUpdate value) { return new ChangeOp(new FormsUpdateValue(value)); } @@ -174,6 +182,10 @@ public boolean isAnnotationsReorder() { return value instanceof AnnotationsReorderValue; } + public boolean isAnnotationsCopy() { + return value instanceof AnnotationsCopyValue; + } + public boolean isFormsSetValue() { return value instanceof FormsSetValueValue; } @@ -194,6 +206,10 @@ public boolean isFormsCreate() { return value instanceof FormsCreateValue; } + public boolean isFormsCopy() { + return value instanceof FormsCopyValue; + } + public boolean isFormsUpdate() { return value instanceof FormsUpdateValue; } @@ -322,6 +338,13 @@ public Optional getAnnotationsReorder() { return Optional.empty(); } + public Optional getAnnotationsCopy() { + if (isAnnotationsCopy()) { + return Optional.of(((AnnotationsCopyValue) value).value); + } + return Optional.empty(); + } + public Optional getFormsSetValue() { if (isFormsSetValue()) { return Optional.of(((FormsSetValueValue) value).value); @@ -357,6 +380,13 @@ public Optional getFormsCreate() { return Optional.empty(); } + public Optional getFormsCopy() { + if (isFormsCopy()) { + return Optional.of(((FormsCopyValue) value).value); + } + return Optional.empty(); + } + public Optional getFormsUpdate() { if (isFormsUpdate()) { return Optional.of(((FormsUpdateValue) value).value); @@ -562,6 +592,8 @@ public interface Visitor { T visitAnnotationsReorder(ChangeOpAnnotationsReorder annotationsReorder); + T visitAnnotationsCopy(ChangeOpAnnotationsCopy annotationsCopy); + T visitFormsSetValue(ChangeOpFormsSetValue formsSetValue); T visitFormsSetDisplay(ChangeOpFormsSetDisplay formsSetDisplay); @@ -572,6 +604,8 @@ public interface Visitor { T visitFormsCreate(ChangeOpFormsCreate formsCreate); + T visitFormsCopy(ChangeOpFormsCopy formsCopy); + T visitFormsUpdate(ChangeOpFormsUpdate formsUpdate); T visitFormsDelete(ChangeOpFormsDelete formsDelete); @@ -629,11 +663,13 @@ public interface Visitor { @JsonSubTypes.Type(AnnotationsUpdateValue.class), @JsonSubTypes.Type(AnnotationsDeleteValue.class), @JsonSubTypes.Type(AnnotationsReorderValue.class), + @JsonSubTypes.Type(AnnotationsCopyValue.class), @JsonSubTypes.Type(FormsSetValueValue.class), @JsonSubTypes.Type(FormsSetDisplayValue.class), @JsonSubTypes.Type(FormsSetAppearanceTextValue.class), @JsonSubTypes.Type(FormsResetValue.class), @JsonSubTypes.Type(FormsCreateValue.class), + @JsonSubTypes.Type(FormsCopyValue.class), @JsonSubTypes.Type(FormsUpdateValue.class), @JsonSubTypes.Type(FormsDeleteValue.class), @JsonSubTypes.Type(FormsAddWidgetValue.class), @@ -824,6 +860,46 @@ public String toString() { } } + @JsonTypeName("annotations.copy") + @JsonIgnoreProperties("type") + private static final class AnnotationsCopyValue implements Value { + @JsonUnwrapped + @JsonIgnoreProperties(value = "type", allowSetters = true) + private ChangeOpAnnotationsCopy value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private AnnotationsCopyValue() {} + + private AnnotationsCopyValue(ChangeOpAnnotationsCopy value) { + this.value = value; + } + + @java.lang.Override + public T visit(Visitor visitor) { + return visitor.visitAnnotationsCopy(value); + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof AnnotationsCopyValue && equalTo((AnnotationsCopyValue) other); + } + + private boolean equalTo(AnnotationsCopyValue other) { + return value.equals(other.value); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.value); + } + + @java.lang.Override + public String toString() { + return "ChangeOp{" + "value: " + value + "}"; + } + } + @JsonTypeName("forms.setValue") @JsonIgnoreProperties("type") private static final class FormsSetValueValue implements Value { @@ -1024,6 +1100,46 @@ public String toString() { } } + @JsonTypeName("forms.copy") + @JsonIgnoreProperties("type") + private static final class FormsCopyValue implements Value { + @JsonUnwrapped + @JsonIgnoreProperties(value = "type", allowSetters = true) + private ChangeOpFormsCopy value; + + @JsonCreator(mode = JsonCreator.Mode.PROPERTIES) + private FormsCopyValue() {} + + private FormsCopyValue(ChangeOpFormsCopy value) { + this.value = value; + } + + @java.lang.Override + public T visit(Visitor visitor) { + return visitor.visitFormsCopy(value); + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof FormsCopyValue && equalTo((FormsCopyValue) other); + } + + private boolean equalTo(FormsCopyValue other) { + return value.equals(other.value); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.value); + } + + @java.lang.Override + public String toString() { + return "ChangeOp{" + "value: " + value + "}"; + } + } + @JsonTypeName("forms.update") @JsonIgnoreProperties("type") private static final class FormsUpdateValue implements Value { diff --git a/src/main/java/api/types/ChangeOpAnnotationsCopy.java b/src/main/java/api/types/ChangeOpAnnotationsCopy.java new file mode 100644 index 0000000..66de8b0 --- /dev/null +++ b/src/main/java/api/types/ChangeOpAnnotationsCopy.java @@ -0,0 +1,191 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeOpAnnotationsCopy.Builder.class) +public final class ChangeOpAnnotationsCopy { + private final List refs; + + private final Optional page; + + private final Optional offset; + + private final Optional> objectNumbers; + + private final Map additionalProperties; + + private ChangeOpAnnotationsCopy( + List refs, + Optional page, + Optional offset, + Optional> objectNumbers, + Map additionalProperties) { + this.refs = refs; + this.page = page; + this.offset = offset; + this.objectNumbers = objectNumbers; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("refs") + public List getRefs() { + return refs; + } + + @JsonProperty("page") + public Optional getPage() { + return page; + } + + @JsonProperty("offset") + public Optional getOffset() { + return offset; + } + + @JsonProperty("objectNumbers") + public Optional> getObjectNumbers() { + return objectNumbers; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeOpAnnotationsCopy && equalTo((ChangeOpAnnotationsCopy) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeOpAnnotationsCopy other) { + return refs.equals(other.refs) + && page.equals(other.page) + && offset.equals(other.offset) + && objectNumbers.equals(other.objectNumbers); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.refs, this.page, this.offset, this.objectNumbers); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static Builder builder() { + return new Builder(); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + private List refs = new ArrayList<>(); + + private Optional page = Optional.empty(); + + private Optional offset = Optional.empty(); + + private Optional> objectNumbers = Optional.empty(); + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + public Builder from(ChangeOpAnnotationsCopy other) { + refs(other.getRefs()); + page(other.getPage()); + offset(other.getOffset()); + objectNumbers(other.getObjectNumbers()); + return this; + } + + @JsonSetter(value = "refs", nulls = Nulls.SKIP) + public Builder refs(List refs) { + this.refs.clear(); + if (refs != null) { + this.refs.addAll(refs); + } + return this; + } + + public Builder addRefs(AnnotationRef refs) { + this.refs.add(refs); + return this; + } + + public Builder addAllRefs(List refs) { + if (refs != null) { + this.refs.addAll(refs); + } + return this; + } + + @JsonSetter(value = "page", nulls = Nulls.SKIP) + public Builder page(Optional page) { + this.page = page; + return this; + } + + public Builder page(PageRef page) { + this.page = Optional.ofNullable(page); + return this; + } + + @JsonSetter(value = "offset", nulls = Nulls.SKIP) + public Builder offset(Optional offset) { + this.offset = offset; + return this; + } + + public Builder offset(ChangeOpAnnotationsCopyOffset offset) { + this.offset = Optional.ofNullable(offset); + return this; + } + + @JsonSetter(value = "objectNumbers", nulls = Nulls.SKIP) + public Builder objectNumbers(Optional> objectNumbers) { + this.objectNumbers = objectNumbers; + return this; + } + + public Builder objectNumbers(List objectNumbers) { + this.objectNumbers = Optional.ofNullable(objectNumbers); + return this; + } + + public ChangeOpAnnotationsCopy build() { + return new ChangeOpAnnotationsCopy(refs, page, offset, objectNumbers, additionalProperties); + } + + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeOpAnnotationsCopyOffset.java b/src/main/java/api/types/ChangeOpAnnotationsCopyOffset.java new file mode 100644 index 0000000..ce3d583 --- /dev/null +++ b/src/main/java/api/types/ChangeOpAnnotationsCopyOffset.java @@ -0,0 +1,139 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeOpAnnotationsCopyOffset.Builder.class) +public final class ChangeOpAnnotationsCopyOffset { + private final double x; + + private final double y; + + private final Map additionalProperties; + + private ChangeOpAnnotationsCopyOffset(double x, double y, Map additionalProperties) { + this.x = x; + this.y = y; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("x") + public double getX() { + return x; + } + + @JsonProperty("y") + public double getY() { + return y; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeOpAnnotationsCopyOffset && equalTo((ChangeOpAnnotationsCopyOffset) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeOpAnnotationsCopyOffset other) { + return x == other.x && y == other.y; + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.x, this.y); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static XStage builder() { + return new Builder(); + } + + public interface XStage { + YStage x(double x); + + Builder from(ChangeOpAnnotationsCopyOffset other); + } + + public interface YStage { + _FinalStage y(double y); + } + + public interface _FinalStage { + ChangeOpAnnotationsCopyOffset build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements XStage, YStage, _FinalStage { + private double x; + + private double y; + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeOpAnnotationsCopyOffset other) { + x(other.getX()); + y(other.getY()); + return this; + } + + @java.lang.Override + @JsonSetter("x") + public YStage x(double x) { + this.x = x; + return this; + } + + @java.lang.Override + @JsonSetter("y") + public _FinalStage y(double y) { + this.y = y; + return this; + } + + @java.lang.Override + public ChangeOpAnnotationsCopyOffset build() { + return new ChangeOpAnnotationsCopyOffset(x, y, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeOpFormsCopy.java b/src/main/java/api/types/ChangeOpFormsCopy.java new file mode 100644 index 0000000..33fcbd1 --- /dev/null +++ b/src/main/java/api/types/ChangeOpFormsCopy.java @@ -0,0 +1,239 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.annotation.Nulls; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeOpFormsCopy.Builder.class) +public final class ChangeOpFormsCopy { + private final List fields; + + private final Optional> widgets; + + private final Optional page; + + private final Optional offset; + + private final Optional values; + + private final Optional> objectNumbers; + + private final Map additionalProperties; + + private ChangeOpFormsCopy( + List fields, + Optional> widgets, + Optional page, + Optional offset, + Optional values, + Optional> objectNumbers, + Map additionalProperties) { + this.fields = fields; + this.widgets = widgets; + this.page = page; + this.offset = offset; + this.values = values; + this.objectNumbers = objectNumbers; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("fields") + public List getFields() { + return fields; + } + + @JsonProperty("widgets") + public Optional> getWidgets() { + return widgets; + } + + @JsonProperty("page") + public Optional getPage() { + return page; + } + + @JsonProperty("offset") + public Optional getOffset() { + return offset; + } + + @JsonProperty("values") + public Optional getValues() { + return values; + } + + @JsonProperty("objectNumbers") + public Optional> getObjectNumbers() { + return objectNumbers; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeOpFormsCopy && equalTo((ChangeOpFormsCopy) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeOpFormsCopy other) { + return fields.equals(other.fields) + && widgets.equals(other.widgets) + && page.equals(other.page) + && offset.equals(other.offset) + && values.equals(other.values) + && objectNumbers.equals(other.objectNumbers); + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.fields, this.widgets, this.page, this.offset, this.values, this.objectNumbers); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static Builder builder() { + return new Builder(); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder { + private List fields = new ArrayList<>(); + + private Optional> widgets = Optional.empty(); + + private Optional page = Optional.empty(); + + private Optional offset = Optional.empty(); + + private Optional values = Optional.empty(); + + private Optional> objectNumbers = Optional.empty(); + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + public Builder from(ChangeOpFormsCopy other) { + fields(other.getFields()); + widgets(other.getWidgets()); + page(other.getPage()); + offset(other.getOffset()); + values(other.getValues()); + objectNumbers(other.getObjectNumbers()); + return this; + } + + @JsonSetter(value = "fields", nulls = Nulls.SKIP) + public Builder fields(List fields) { + this.fields.clear(); + if (fields != null) { + this.fields.addAll(fields); + } + return this; + } + + public Builder addFields(FormFieldRef fields) { + this.fields.add(fields); + return this; + } + + public Builder addAllFields(List fields) { + if (fields != null) { + this.fields.addAll(fields); + } + return this; + } + + @JsonSetter(value = "widgets", nulls = Nulls.SKIP) + public Builder widgets(Optional> widgets) { + this.widgets = widgets; + return this; + } + + public Builder widgets(List widgets) { + this.widgets = Optional.ofNullable(widgets); + return this; + } + + @JsonSetter(value = "page", nulls = Nulls.SKIP) + public Builder page(Optional page) { + this.page = page; + return this; + } + + public Builder page(PageRef page) { + this.page = Optional.ofNullable(page); + return this; + } + + @JsonSetter(value = "offset", nulls = Nulls.SKIP) + public Builder offset(Optional offset) { + this.offset = offset; + return this; + } + + public Builder offset(ChangeOpFormsCopyOffset offset) { + this.offset = Optional.ofNullable(offset); + return this; + } + + @JsonSetter(value = "values", nulls = Nulls.SKIP) + public Builder values(Optional values) { + this.values = values; + return this; + } + + public Builder values(Boolean values) { + this.values = Optional.ofNullable(values); + return this; + } + + @JsonSetter(value = "objectNumbers", nulls = Nulls.SKIP) + public Builder objectNumbers(Optional> objectNumbers) { + this.objectNumbers = objectNumbers; + return this; + } + + public Builder objectNumbers(List objectNumbers) { + this.objectNumbers = Optional.ofNullable(objectNumbers); + return this; + } + + public ChangeOpFormsCopy build() { + return new ChangeOpFormsCopy(fields, widgets, page, offset, values, objectNumbers, additionalProperties); + } + + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +} diff --git a/src/main/java/api/types/ChangeOpFormsCopyOffset.java b/src/main/java/api/types/ChangeOpFormsCopyOffset.java new file mode 100644 index 0000000..e6d6e56 --- /dev/null +++ b/src/main/java/api/types/ChangeOpFormsCopyOffset.java @@ -0,0 +1,139 @@ +/** + * This file was auto-generated by Fern from our API Definition. + */ +package com.cloudpdf.api.types; + +import com.cloudpdf.api.core.ObjectMappers; +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonSetter; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +@JsonInclude(JsonInclude.Include.NON_ABSENT) +@JsonDeserialize(builder = ChangeOpFormsCopyOffset.Builder.class) +public final class ChangeOpFormsCopyOffset { + private final double x; + + private final double y; + + private final Map additionalProperties; + + private ChangeOpFormsCopyOffset(double x, double y, Map additionalProperties) { + this.x = x; + this.y = y; + this.additionalProperties = additionalProperties; + } + + @JsonProperty("x") + public double getX() { + return x; + } + + @JsonProperty("y") + public double getY() { + return y; + } + + @java.lang.Override + public boolean equals(Object other) { + if (this == other) return true; + return other instanceof ChangeOpFormsCopyOffset && equalTo((ChangeOpFormsCopyOffset) other); + } + + @JsonAnyGetter + public Map getAdditionalProperties() { + return this.additionalProperties; + } + + private boolean equalTo(ChangeOpFormsCopyOffset other) { + return x == other.x && y == other.y; + } + + @java.lang.Override + public int hashCode() { + return Objects.hash(this.x, this.y); + } + + @java.lang.Override + public String toString() { + return ObjectMappers.stringify(this); + } + + public static XStage builder() { + return new Builder(); + } + + public interface XStage { + YStage x(double x); + + Builder from(ChangeOpFormsCopyOffset other); + } + + public interface YStage { + _FinalStage y(double y); + } + + public interface _FinalStage { + ChangeOpFormsCopyOffset build(); + + _FinalStage additionalProperty(String key, Object value); + + _FinalStage additionalProperties(Map additionalProperties); + } + + @JsonIgnoreProperties(ignoreUnknown = true) + public static final class Builder implements XStage, YStage, _FinalStage { + private double x; + + private double y; + + @JsonAnySetter + private Map additionalProperties = new HashMap<>(); + + private Builder() {} + + @java.lang.Override + public Builder from(ChangeOpFormsCopyOffset other) { + x(other.getX()); + y(other.getY()); + return this; + } + + @java.lang.Override + @JsonSetter("x") + public YStage x(double x) { + this.x = x; + return this; + } + + @java.lang.Override + @JsonSetter("y") + public _FinalStage y(double y) { + this.y = y; + return this; + } + + @java.lang.Override + public ChangeOpFormsCopyOffset build() { + return new ChangeOpFormsCopyOffset(x, y, additionalProperties); + } + + @java.lang.Override + public Builder additionalProperty(String key, Object value) { + this.additionalProperties.put(key, value); + return this; + } + + @java.lang.Override + public Builder additionalProperties(Map additionalProperties) { + this.additionalProperties.putAll(additionalProperties); + return this; + } + } +}