From 8684216bbcffdc6d4f2b320e4f72be3c8cd66c26 Mon Sep 17 00:00:00 2001 From: fern-api <115122769+fern-api[bot]@users.noreply.github.com> Date: Sat, 12 Apr 2025 15:47:22 +0000 Subject: [PATCH] SDK regeneration --- .../com/intercom/api/core/ApiVersion.java | 232 +++++- .../com/intercom/api/core/ClientOptions.java | 27 +- .../api/resources/aiagent/types/AiAgent.java | 103 ++- .../requests/CreateArticleRequest.java | 143 +++- .../requests/UpdateArticleRequest.java | 143 +++- .../api/resources/articles/types/Article.java | 72 +- .../articles/types/ArticleListItem.java | 72 +- .../types/ArticleSearchHighlights.java | 143 +++- .../requests/CreateConversationRequest.java | 82 +- .../conversations/types/Conversation.java | 153 +++- .../requests/CreateDataAttributeRequest.java | 183 +++- .../dataattributes/types/DataAttribute.java | 173 +++- .../types/DataAttributesListRequestModel.java | 87 +- .../dataexport/types/DataExport.java | 112 ++- .../api/resources/messages/types/Message.java | 93 ++- .../api/resources/news/types/NewsItem.java | 72 +- .../api/resources/segments/types/Segment.java | 72 +- .../types/SubscriptionType.java | 226 ++++- .../tickets/requests/UpdateTicketRequest.java | 82 +- .../api/resources/tickets/types/Ticket.java | 175 +++- .../resources/tickets/types/TicketPart.java | 188 ++++- .../resources/tickets/types/TicketType.java | 82 +- .../CreateTicketTypeAttributeRequest.java | 122 ++- .../requests/CreateTicketTypeRequest.java | 82 +- .../requests/UpdateTicketTypeRequest.java | 82 +- .../com/intercom/api/types/ActivityLog.java | 778 ++++++++++++++++-- .../types/AdminReplyConversationRequest.java | 73 +- .../api/types/AdminReplyTicketRequest.java | 83 +- .../intercom/api/types/ArticleContent.java | 72 +- .../api/types/AssignConversationRequest.java | 72 +- .../intercom/api/types/ButtonComponent.java | 82 +- .../intercom/api/types/CheckboxComponent.java | 82 +- .../java/com/intercom/api/types/Context.java | 92 ++- .../api/types/ConversationSource.java | 152 +++- .../api/types/CreateMessageRequest.java | 142 +++- .../intercom/api/types/DropdownComponent.java | 82 +- .../intercom/api/types/ImageComponent.java | 92 ++- .../intercom/api/types/InputComponent.java | 82 +- .../com/intercom/api/types/LinkedObject.java | 72 +- .../types/MultipleFilterSearchRequest.java | 72 +- .../intercom/api/types/NewsItemRequest.java | 72 +- .../api/types/SingleFilterSearchRequest.java | 152 +++- .../api/types/SingleSelectComponent.java | 82 +- .../com/intercom/api/types/SlaApplied.java | 92 ++- .../intercom/api/types/SpacerComponent.java | 102 ++- .../com/intercom/api/types/TextComponent.java | 173 +++- .../intercom/api/types/TicketPartAuthor.java | 92 ++- .../com/intercom/api/types/TicketReply.java | 82 +- .../api/types/TicketTypeAttribute.java | 122 ++- 49 files changed, 5393 insertions(+), 605 deletions(-) diff --git a/src/main/java/com/intercom/api/core/ApiVersion.java b/src/main/java/com/intercom/api/core/ApiVersion.java index a553eb3..e0f2c7b 100644 --- a/src/main/java/com/intercom/api/core/ApiVersion.java +++ b/src/main/java/com/intercom/api/core/ApiVersion.java @@ -3,56 +3,240 @@ */ package com.intercom.api.core; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; -public enum ApiVersion { - _1_0("1.0"), +public final class ApiVersion { + public static final ApiVersion _2_1 = new ApiVersion(Value._2_1, "2.1"); - _1_1("1.1"), + public static final ApiVersion _2_2 = new ApiVersion(Value._2_2, "2.2"); - _1_2("1.2"), + public static final ApiVersion _1_0 = new ApiVersion(Value._1_0, "1.0"); - _1_3("1.3"), + public static final ApiVersion _2_3 = new ApiVersion(Value._2_3, "2.3"); - _1_4("1.4"), + public static final ApiVersion _1_1 = new ApiVersion(Value._1_1, "1.1"); - _2_0("2.0"), + public static final ApiVersion _2_4 = new ApiVersion(Value._2_4, "2.4"); - _2_1("2.1"), + public static final ApiVersion _1_2 = new ApiVersion(Value._1_2, "1.2"); - _2_2("2.2"), + public static final ApiVersion _2_5 = new ApiVersion(Value._2_5, "2.5"); - _2_3("2.3"), + public static final ApiVersion _1_3 = new ApiVersion(Value._1_3, "1.3"); - _2_4("2.4"), + public static final ApiVersion _2_6 = new ApiVersion(Value._2_6, "2.6"); - _2_5("2.5"), + public static final ApiVersion _1_4 = new ApiVersion(Value._1_4, "1.4"); - _2_6("2.6"), + public static final ApiVersion _2_7 = new ApiVersion(Value._2_7, "2.7"); - _2_7("2.7"), + public static final ApiVersion _2_8 = new ApiVersion(Value._2_8, "2.8"); - _2_8("2.8"), + public static final ApiVersion _2_10 = new ApiVersion(Value._2_10, "2.10"); - _2_9("2.9"), + public static final ApiVersion _2_9 = new ApiVersion(Value._2_9, "2.9"); - _2_10("2.10"), + public static final ApiVersion _2_11 = new ApiVersion(Value._2_11, "2.11"); - _2_11("2.11"), + public static final ApiVersion UNSTABLE = new ApiVersion(Value.UNSTABLE, "Unstable"); - UNSTABLE("Unstable"), + public static final ApiVersion _2_0 = new ApiVersion(Value._2_0, "2.0"); - CURRENT("2.11"); + private final Value value; - private final String value; + private final String string; - ApiVersion(String value) { + ApiVersion(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof ApiVersion && this.string.equals(((ApiVersion) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case _2_1: + return visitor.visit_21(); + case _2_2: + return visitor.visit_22(); + case _1_0: + return visitor.visit_10(); + case _2_3: + return visitor.visit_23(); + case _1_1: + return visitor.visit_11(); + case _2_4: + return visitor.visit_24(); + case _1_2: + return visitor.visit_12(); + case _2_5: + return visitor.visit_25(); + case _1_3: + return visitor.visit_13(); + case _2_6: + return visitor.visit_26(); + case _1_4: + return visitor.visit_14(); + case _2_7: + return visitor.visit_27(); + case _2_8: + return visitor.visit_28(); + case _2_10: + return visitor.visit_210(); + case _2_9: + return visitor.visit_29(); + case _2_11: + return visitor.visit_211(); + case UNSTABLE: + return visitor.visitUnstable(); + case _2_0: + return visitor.visit_20(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ApiVersion valueOf(String value) { + switch (value) { + case "2.1": + return _2_1; + case "2.2": + return _2_2; + case "1.0": + return _1_0; + case "2.3": + return _2_3; + case "1.1": + return _1_1; + case "2.4": + return _2_4; + case "1.2": + return _1_2; + case "2.5": + return _2_5; + case "1.3": + return _1_3; + case "2.6": + return _2_6; + case "1.4": + return _1_4; + case "2.7": + return _2_7; + case "2.8": + return _2_8; + case "2.10": + return _2_10; + case "2.9": + return _2_9; + case "2.11": + return _2_11; + case "Unstable": + return UNSTABLE; + case "2.0": + return _2_0; + default: + return new ApiVersion(Value.UNKNOWN, value); + } + } + + public enum Value { + _1_0, + + _1_1, + + _1_2, + + _1_3, + + _1_4, + + _2_0, + + _2_1, + + _2_2, + + _2_3, + + _2_4, + + _2_5, + + _2_6, + + _2_7, + + _2_8, + + _2_9, + + _2_10, + + _2_11, + + UNSTABLE, + + UNKNOWN + } + + public interface Visitor { + T visit_10(); + + T visit_11(); + + T visit_12(); + + T visit_13(); + + T visit_14(); + + T visit_20(); + + T visit_21(); + + T visit_22(); + + T visit_23(); + + T visit_24(); + + T visit_25(); + + T visit_26(); + + T visit_27(); + + T visit_28(); + + T visit_29(); + + T visit_210(); + + T visit_211(); + + T visitUnstable(); + + T visitUnknown(String unknownType); } } diff --git a/src/main/java/com/intercom/api/core/ClientOptions.java b/src/main/java/com/intercom/api/core/ClientOptions.java index 8107f56..a8bff07 100644 --- a/src/main/java/com/intercom/api/core/ClientOptions.java +++ b/src/main/java/com/intercom/api/core/ClientOptions.java @@ -27,30 +27,7 @@ public final class ClientOptions { private final ApiVersion version; /** - * @param version Defaults to "{\n" - * + " \"name\" : {\n" - * + " \"wireValue\" : \"2.11\",\n" - * + " \"name\" : {\n" - * + " \"originalName\" : \"2.11\",\n" - * + " \"camelCase\" : {\n" - * + " \"unsafeName\" : \"211\",\n" - * + " \"safeName\" : \"_211\"\n" - * + " },\n" - * + " \"pascalCase\" : {\n" - * + " \"unsafeName\" : \"211\",\n" - * + " \"safeName\" : \"_211\"\n" - * + " },\n" - * + " \"snakeCase\" : {\n" - * + " \"unsafeName\" : \"2_11\",\n" - * + " \"safeName\" : \"_2_11\"\n" - * + " },\n" - * + " \"screamingSnakeCase\" : {\n" - * + " \"unsafeName\" : \"2_11\",\n" - * + " \"safeName\" : \"_2_11\"\n" - * + " }\n" - * + " }\n" - * + " }\n" - * + "}" if empty + * @param version Defaults to "2.11" if empty */ private ClientOptions( Environment environment, @@ -73,7 +50,7 @@ private ClientOptions( this.headerSuppliers = headerSuppliers; this.httpClient = httpClient; this.timeout = timeout; - this.version = version.orElse(ApiVersion.CURRENT); + this.version = version.orElse(ApiVersion._2_11); this.headers.put("Intercom-Version", this.version.toString()); } diff --git a/src/main/java/com/intercom/api/resources/aiagent/types/AiAgent.java b/src/main/java/com/intercom/api/resources/aiagent/types/AiAgent.java index 3e2c6eb..174bd55 100644 --- a/src/main/java/com/intercom/api/resources/aiagent/types/AiAgent.java +++ b/src/main/java/com/intercom/api/resources/aiagent/types/AiAgent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -343,27 +344,109 @@ public AiAgent build() { } } - public enum SourceType { - ESSENTIALS_PLAN_SETUP("essentials_plan_setup"), + public static final class SourceType { + public static final SourceType WORKFLOW = new SourceType(Value.WORKFLOW, "workflow"); - PROFILE("profile"), + public static final SourceType WORKFLOW_PREVIEW = new SourceType(Value.WORKFLOW_PREVIEW, "workflow_preview"); - WORKFLOW("workflow"), + public static final SourceType FIN_PREVIEW = new SourceType(Value.FIN_PREVIEW, "fin_preview"); - WORKFLOW_PREVIEW("workflow_preview"), + public static final SourceType ESSENTIALS_PLAN_SETUP = + new SourceType(Value.ESSENTIALS_PLAN_SETUP, "essentials_plan_setup"); - FIN_PREVIEW("fin_preview"); + public static final SourceType PROFILE = new SourceType(Value.PROFILE, "profile"); - private final String value; + private final Value value; - SourceType(String value) { + private final String string; + + SourceType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof SourceType && this.string.equals(((SourceType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case WORKFLOW: + return visitor.visitWorkflow(); + case WORKFLOW_PREVIEW: + return visitor.visitWorkflowPreview(); + case FIN_PREVIEW: + return visitor.visitFinPreview(); + case ESSENTIALS_PLAN_SETUP: + return visitor.visitEssentialsPlanSetup(); + case PROFILE: + return visitor.visitProfile(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static SourceType valueOf(String value) { + switch (value) { + case "workflow": + return WORKFLOW; + case "workflow_preview": + return WORKFLOW_PREVIEW; + case "fin_preview": + return FIN_PREVIEW; + case "essentials_plan_setup": + return ESSENTIALS_PLAN_SETUP; + case "profile": + return PROFILE; + default: + return new SourceType(Value.UNKNOWN, value); + } + } + + public enum Value { + ESSENTIALS_PLAN_SETUP, + + PROFILE, + + WORKFLOW, + + WORKFLOW_PREVIEW, + + FIN_PREVIEW, + + UNKNOWN + } + + public interface Visitor { + T visitEssentialsPlanSetup(); + + T visitProfile(); + + T visitWorkflow(); + + T visitWorkflowPreview(); + + T visitFinPreview(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/articles/requests/CreateArticleRequest.java b/src/main/java/com/intercom/api/resources/articles/requests/CreateArticleRequest.java index 86c6aac..fdafcd5 100644 --- a/src/main/java/com/intercom/api/resources/articles/requests/CreateArticleRequest.java +++ b/src/main/java/com/intercom/api/resources/articles/requests/CreateArticleRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -376,39 +377,153 @@ public CreateArticleRequest build() { } } - public enum State { - PUBLISHED("published"), + public static final class State { + public static final State PUBLISHED = new State(Value.PUBLISHED, "published"); - DRAFT("draft"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PUBLISHED: + return visitor.visitPublished(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "published": + return PUBLISHED; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + PUBLISHED, + + DRAFT, + + UNKNOWN + } + + public interface Visitor { + T visitPublished(); + + T visitDraft(); + + T visitUnknown(String unknownType); } } - public enum ParentType { - COLLECTION("collection"), + public static final class ParentType { + public static final ParentType SECTION = new ParentType(Value.SECTION, "section"); - SECTION("section"); + public static final ParentType COLLECTION = new ParentType(Value.COLLECTION, "collection"); - private final String value; + private final Value value; - ParentType(String value) { + private final String string; + + ParentType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof ParentType && this.string.equals(((ParentType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SECTION: + return visitor.visitSection(); + case COLLECTION: + return visitor.visitCollection(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ParentType valueOf(String value) { + switch (value) { + case "section": + return SECTION; + case "collection": + return COLLECTION; + default: + return new ParentType(Value.UNKNOWN, value); + } + } + + public enum Value { + COLLECTION, + + SECTION, + + UNKNOWN + } + + public interface Visitor { + T visitCollection(); + + T visitSection(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/articles/requests/UpdateArticleRequest.java b/src/main/java/com/intercom/api/resources/articles/requests/UpdateArticleRequest.java index 0db8510..2799159 100644 --- a/src/main/java/com/intercom/api/resources/articles/requests/UpdateArticleRequest.java +++ b/src/main/java/com/intercom/api/resources/articles/requests/UpdateArticleRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -421,39 +422,153 @@ public UpdateArticleRequest build() { } } - public enum ParentType { - COLLECTION("collection"), + public static final class ParentType { + public static final ParentType SECTION = new ParentType(Value.SECTION, "section"); - SECTION("section"); + public static final ParentType COLLECTION = new ParentType(Value.COLLECTION, "collection"); - private final String value; + private final Value value; - ParentType(String value) { + private final String string; + + ParentType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof ParentType && this.string.equals(((ParentType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SECTION: + return visitor.visitSection(); + case COLLECTION: + return visitor.visitCollection(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ParentType valueOf(String value) { + switch (value) { + case "section": + return SECTION; + case "collection": + return COLLECTION; + default: + return new ParentType(Value.UNKNOWN, value); + } + } + + public enum Value { + COLLECTION, + + SECTION, + + UNKNOWN + } + + public interface Visitor { + T visitCollection(); + + T visitSection(); + + T visitUnknown(String unknownType); } } - public enum State { - PUBLISHED("published"), + public static final class State { + public static final State PUBLISHED = new State(Value.PUBLISHED, "published"); - DRAFT("draft"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PUBLISHED: + return visitor.visitPublished(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "published": + return PUBLISHED; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + PUBLISHED, + + DRAFT, + + UNKNOWN + } + + public interface Visitor { + T visitPublished(); + + T visitDraft(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/articles/types/Article.java b/src/main/java/com/intercom/api/resources/articles/types/Article.java index eae803d..e209512 100644 --- a/src/main/java/com/intercom/api/resources/articles/types/Article.java +++ b/src/main/java/com/intercom/api/resources/articles/types/Article.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -690,21 +691,78 @@ public Article build() { } } - public enum State { - PUBLISHED("published"), + public static final class State { + public static final State PUBLISHED = new State(Value.PUBLISHED, "published"); - DRAFT("draft"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PUBLISHED: + return visitor.visitPublished(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "published": + return PUBLISHED; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + PUBLISHED, + + DRAFT, + + UNKNOWN + } + + public interface Visitor { + T visitPublished(); + + T visitDraft(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/articles/types/ArticleListItem.java b/src/main/java/com/intercom/api/resources/articles/types/ArticleListItem.java index 9b7f1e5..c1a639f 100644 --- a/src/main/java/com/intercom/api/resources/articles/types/ArticleListItem.java +++ b/src/main/java/com/intercom/api/resources/articles/types/ArticleListItem.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -657,21 +658,78 @@ public ArticleListItem build() { } } - public enum State { - PUBLISHED("published"), + public static final class State { + public static final State PUBLISHED = new State(Value.PUBLISHED, "published"); - DRAFT("draft"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PUBLISHED: + return visitor.visitPublished(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "published": + return PUBLISHED; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + PUBLISHED, + + DRAFT, + + UNKNOWN + } + + public interface Visitor { + T visitPublished(); + + T visitDraft(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/articles/types/ArticleSearchHighlights.java b/src/main/java/com/intercom/api/resources/articles/types/ArticleSearchHighlights.java index cdb5065..f6259d9 100644 --- a/src/main/java/com/intercom/api/resources/articles/types/ArticleSearchHighlights.java +++ b/src/main/java/com/intercom/api/resources/articles/types/ArticleSearchHighlights.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -319,21 +320,78 @@ public HighlightedTitleItem build() { } } - public enum Type { - HIGHLIGHT("highlight"), + public static final class Type { + public static final Type PLAIN = new Type(Value.PLAIN, "plain"); - PLAIN("plain"); + public static final Type HIGHLIGHT = new Type(Value.HIGHLIGHT, "highlight"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PLAIN: + return visitor.visitPlain(); + case HIGHLIGHT: + return visitor.visitHighlight(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "plain": + return PLAIN; + case "highlight": + return HIGHLIGHT; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + HIGHLIGHT, + + PLAIN, + + UNKNOWN + } + + public interface Visitor { + T visitHighlight(); + + T visitPlain(); + + T visitUnknown(String unknownType); } } } @@ -443,21 +501,78 @@ public HighlightedSummaryItemItem build() { } } - public enum Type { - HIGHLIGHT("highlight"), + public static final class Type { + public static final Type PLAIN = new Type(Value.PLAIN, "plain"); - PLAIN("plain"); + public static final Type HIGHLIGHT = new Type(Value.HIGHLIGHT, "highlight"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PLAIN: + return visitor.visitPlain(); + case HIGHLIGHT: + return visitor.visitHighlight(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "plain": + return PLAIN; + case "highlight": + return HIGHLIGHT; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + HIGHLIGHT, + + PLAIN, + + UNKNOWN + } + + public interface Visitor { + T visitHighlight(); + + T visitPlain(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/conversations/requests/CreateConversationRequest.java b/src/main/java/com/intercom/api/resources/conversations/requests/CreateConversationRequest.java index fbf4497..b05af58 100644 --- a/src/main/java/com/intercom/api/resources/conversations/requests/CreateConversationRequest.java +++ b/src/main/java/com/intercom/api/resources/conversations/requests/CreateConversationRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -288,23 +289,88 @@ public From build() { } } - public enum Type { - LEAD("lead"), + public static final class Type { + public static final Type USER = new Type(Value.USER, "user"); - USER("user"), + public static final Type CONTACT = new Type(Value.CONTACT, "contact"); - CONTACT("contact"); + public static final Type LEAD = new Type(Value.LEAD, "lead"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case USER: + return visitor.visitUser(); + case CONTACT: + return visitor.visitContact(); + case LEAD: + return visitor.visitLead(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "user": + return USER; + case "contact": + return CONTACT; + case "lead": + return LEAD; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + LEAD, + + USER, + + CONTACT, + + UNKNOWN + } + + public interface Visitor { + T visitLead(); + + T visitUser(); + + T visitContact(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/conversations/types/Conversation.java b/src/main/java/com/intercom/api/resources/conversations/types/Conversation.java index 1401589..cd10317 100644 --- a/src/main/java/com/intercom/api/resources/conversations/types/Conversation.java +++ b/src/main/java/com/intercom/api/resources/conversations/types/Conversation.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -989,41 +990,163 @@ public Conversation build() { } } - public enum Priority { - PRIORITY("priority"), + public static final class Priority { + public static final Priority PRIORITY = new Priority(Value.PRIORITY, "priority"); - NOT_PRIORITY("not_priority"); + public static final Priority NOT_PRIORITY = new Priority(Value.NOT_PRIORITY, "not_priority"); - private final String value; + private final Value value; - Priority(String value) { + private final String string; + + Priority(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Priority && this.string.equals(((Priority) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PRIORITY: + return visitor.visitPriority(); + case NOT_PRIORITY: + return visitor.visitNotPriority(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Priority valueOf(String value) { + switch (value) { + case "priority": + return PRIORITY; + case "not_priority": + return NOT_PRIORITY; + default: + return new Priority(Value.UNKNOWN, value); + } + } + + public enum Value { + PRIORITY, + + NOT_PRIORITY, + + UNKNOWN + } + + public interface Visitor { + T visitPriority(); + + T visitNotPriority(); + + T visitUnknown(String unknownType); } } - public enum State { - OPEN("open"), + public static final class State { + public static final State SNOOZED = new State(Value.SNOOZED, "snoozed"); + + public static final State CLOSED = new State(Value.CLOSED, "closed"); - CLOSED("closed"), + public static final State OPEN = new State(Value.OPEN, "open"); - SNOOZED("snoozed"); + private final Value value; - private final String value; + private final String string; - State(String value) { + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SNOOZED: + return visitor.visitSnoozed(); + case CLOSED: + return visitor.visitClosed(); + case OPEN: + return visitor.visitOpen(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "snoozed": + return SNOOZED; + case "closed": + return CLOSED; + case "open": + return OPEN; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + OPEN, + + CLOSED, + + SNOOZED, + + UNKNOWN + } + + public interface Visitor { + T visitOpen(); + + T visitClosed(); + + T visitSnoozed(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/dataattributes/requests/CreateDataAttributeRequest.java b/src/main/java/com/intercom/api/resources/dataattributes/requests/CreateDataAttributeRequest.java index fa60253..1707fc2 100644 --- a/src/main/java/com/intercom/api/resources/dataattributes/requests/CreateDataAttributeRequest.java +++ b/src/main/java/com/intercom/api/resources/dataattributes/requests/CreateDataAttributeRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -288,47 +289,193 @@ public CreateDataAttributeRequest build() { } } - public enum Model { - CONTACT("contact"), + public static final class Model { + public static final Model CONTACT = new Model(Value.CONTACT, "contact"); - COMPANY("company"); + public static final Model COMPANY = new Model(Value.COMPANY, "company"); - private final String value; + private final Value value; - Model(String value) { + private final String string; + + Model(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Model && this.string.equals(((Model) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case CONTACT: + return visitor.visitContact(); + case COMPANY: + return visitor.visitCompany(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Model valueOf(String value) { + switch (value) { + case "contact": + return CONTACT; + case "company": + return COMPANY; + default: + return new Model(Value.UNKNOWN, value); + } + } + + public enum Value { + CONTACT, + + COMPANY, + + UNKNOWN + } + + public interface Visitor { + T visitContact(); + + T visitCompany(); + + T visitUnknown(String unknownType); } } - public enum DataType { - STRING("string"), + public static final class DataType { + public static final DataType STRING = new DataType(Value.STRING, "string"); + + public static final DataType FLOAT = new DataType(Value.FLOAT, "float"); - INTEGER("integer"), + public static final DataType INTEGER = new DataType(Value.INTEGER, "integer"); - FLOAT("float"), + public static final DataType DATETIME = new DataType(Value.DATETIME, "datetime"); - BOOLEAN("boolean"), + public static final DataType BOOLEAN = new DataType(Value.BOOLEAN, "boolean"); - DATETIME("datetime"), + public static final DataType DATE = new DataType(Value.DATE, "date"); - DATE("date"); + private final Value value; - private final String value; + private final String string; - DataType(String value) { + DataType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof DataType && this.string.equals(((DataType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case STRING: + return visitor.visitString(); + case FLOAT: + return visitor.visitFloat(); + case INTEGER: + return visitor.visitInteger(); + case DATETIME: + return visitor.visitDatetime(); + case BOOLEAN: + return visitor.visitBoolean(); + case DATE: + return visitor.visitDate(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static DataType valueOf(String value) { + switch (value) { + case "string": + return STRING; + case "float": + return FLOAT; + case "integer": + return INTEGER; + case "datetime": + return DATETIME; + case "boolean": + return BOOLEAN; + case "date": + return DATE; + default: + return new DataType(Value.UNKNOWN, value); + } + } + + public enum Value { + STRING, + + INTEGER, + + FLOAT, + + BOOLEAN, + + DATETIME, + + DATE, + + UNKNOWN + } + + public interface Visitor { + T visitString(); + + T visitInteger(); + + T visitFloat(); + + T visitBoolean(); + + T visitDatetime(); + + T visitDate(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttribute.java b/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttribute.java index a2fa587..d5a2bbc 100644 --- a/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttribute.java +++ b/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttribute.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -686,45 +687,183 @@ public DataAttribute build() { } } - public enum Model { - CONTACT("contact"), + public static final class Model { + public static final Model CONTACT = new Model(Value.CONTACT, "contact"); - COMPANY("company"); + public static final Model COMPANY = new Model(Value.COMPANY, "company"); - private final String value; + private final Value value; - Model(String value) { + private final String string; + + Model(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Model && this.string.equals(((Model) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case CONTACT: + return visitor.visitContact(); + case COMPANY: + return visitor.visitCompany(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Model valueOf(String value) { + switch (value) { + case "contact": + return CONTACT; + case "company": + return COMPANY; + default: + return new Model(Value.UNKNOWN, value); + } + } + + public enum Value { + CONTACT, + + COMPANY, + + UNKNOWN + } + + public interface Visitor { + T visitContact(); + + T visitCompany(); + + T visitUnknown(String unknownType); } } - public enum DataType { - STRING("string"), + public static final class DataType { + public static final DataType STRING = new DataType(Value.STRING, "string"); - INTEGER("integer"), + public static final DataType FLOAT = new DataType(Value.FLOAT, "float"); - FLOAT("float"), + public static final DataType INTEGER = new DataType(Value.INTEGER, "integer"); - BOOLEAN("boolean"), + public static final DataType BOOLEAN = new DataType(Value.BOOLEAN, "boolean"); - DATE("date"); + public static final DataType DATE = new DataType(Value.DATE, "date"); - private final String value; + private final Value value; - DataType(String value) { + private final String string; + + DataType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof DataType && this.string.equals(((DataType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case STRING: + return visitor.visitString(); + case FLOAT: + return visitor.visitFloat(); + case INTEGER: + return visitor.visitInteger(); + case BOOLEAN: + return visitor.visitBoolean(); + case DATE: + return visitor.visitDate(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static DataType valueOf(String value) { + switch (value) { + case "string": + return STRING; + case "float": + return FLOAT; + case "integer": + return INTEGER; + case "boolean": + return BOOLEAN; + case "date": + return DATE; + default: + return new DataType(Value.UNKNOWN, value); + } + } + + public enum Value { + STRING, + + INTEGER, + + FLOAT, + + BOOLEAN, + + DATE, + + UNKNOWN + } + + public interface Visitor { + T visitString(); + + T visitInteger(); + + T visitFloat(); + + T visitBoolean(); + + T visitDate(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttributesListRequestModel.java b/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttributesListRequestModel.java index a6a2810..9180fe1 100644 --- a/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttributesListRequestModel.java +++ b/src/main/java/com/intercom/api/resources/dataattributes/types/DataAttributesListRequestModel.java @@ -3,24 +3,95 @@ */ package com.intercom.api.resources.dataattributes.types; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; -public enum DataAttributesListRequestModel { - CONTACT("contact"), +public final class DataAttributesListRequestModel { + public static final DataAttributesListRequestModel CONTACT = + new DataAttributesListRequestModel(Value.CONTACT, "contact"); - COMPANY("company"), + public static final DataAttributesListRequestModel CONVERSATION = + new DataAttributesListRequestModel(Value.CONVERSATION, "conversation"); - CONVERSATION("conversation"); + public static final DataAttributesListRequestModel COMPANY = + new DataAttributesListRequestModel(Value.COMPANY, "company"); - private final String value; + private final Value value; - DataAttributesListRequestModel(String value) { + private final String string; + + DataAttributesListRequestModel(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof DataAttributesListRequestModel + && this.string.equals(((DataAttributesListRequestModel) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case CONTACT: + return visitor.visitContact(); + case CONVERSATION: + return visitor.visitConversation(); + case COMPANY: + return visitor.visitCompany(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static DataAttributesListRequestModel valueOf(String value) { + switch (value) { + case "contact": + return CONTACT; + case "conversation": + return CONVERSATION; + case "company": + return COMPANY; + default: + return new DataAttributesListRequestModel(Value.UNKNOWN, value); + } + } + + public enum Value { + CONTACT, + + COMPANY, + + CONVERSATION, + + UNKNOWN + } + + public interface Visitor { + T visitContact(); + + T visitCompany(); + + T visitConversation(); + + T visitUnknown(String unknownType); } } diff --git a/src/main/java/com/intercom/api/resources/dataexport/types/DataExport.java b/src/main/java/com/intercom/api/resources/dataexport/types/DataExport.java index d2d4a32..94745fa 100644 --- a/src/main/java/com/intercom/api/resources/dataexport/types/DataExport.java +++ b/src/main/java/com/intercom/api/resources/dataexport/types/DataExport.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -204,29 +205,118 @@ public DataExport build() { } } - public enum Status { - PENDING("pending"), + public static final class Status { + public static final Status FAILED = new Status(Value.FAILED, "failed"); - IN_PROGRESS("in_progress"), + public static final Status COMPLETED = new Status(Value.COMPLETED, "completed"); - FAILED("failed"), + public static final Status NO_DATA = new Status(Value.NO_DATA, "no_data"); - COMPLETED("completed"), + public static final Status PENDING = new Status(Value.PENDING, "pending"); - NO_DATA("no_data"), + public static final Status IN_PROGRESS = new Status(Value.IN_PROGRESS, "in_progress"); - CANCELED("canceled"); + public static final Status CANCELED = new Status(Value.CANCELED, "canceled"); - private final String value; + private final Value value; - Status(String value) { + private final String string; + + Status(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Status && this.string.equals(((Status) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case FAILED: + return visitor.visitFailed(); + case COMPLETED: + return visitor.visitCompleted(); + case NO_DATA: + return visitor.visitNoData(); + case PENDING: + return visitor.visitPending(); + case IN_PROGRESS: + return visitor.visitInProgress(); + case CANCELED: + return visitor.visitCanceled(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Status valueOf(String value) { + switch (value) { + case "failed": + return FAILED; + case "completed": + return COMPLETED; + case "no_data": + return NO_DATA; + case "pending": + return PENDING; + case "in_progress": + return IN_PROGRESS; + case "canceled": + return CANCELED; + default: + return new Status(Value.UNKNOWN, value); + } + } + + public enum Value { + PENDING, + + IN_PROGRESS, + + FAILED, + + COMPLETED, + + NO_DATA, + + CANCELED, + + UNKNOWN + } + + public interface Visitor { + T visitPending(); + + T visitInProgress(); + + T visitFailed(); + + T visitCompleted(); + + T visitNoData(); + + T visitCanceled(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/messages/types/Message.java b/src/main/java/com/intercom/api/resources/messages/types/Message.java index 218de26..76b75d5 100644 --- a/src/main/java/com/intercom/api/resources/messages/types/Message.java +++ b/src/main/java/com/intercom/api/resources/messages/types/Message.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -305,25 +306,99 @@ public Message build() { } } - public enum MessageType { - EMAIL("email"), + public static final class MessageType { + public static final MessageType EMAIL = new MessageType(Value.EMAIL, "email"); - INAPP("inapp"), + public static final MessageType FACEBOOK = new MessageType(Value.FACEBOOK, "facebook"); - FACEBOOK("facebook"), + public static final MessageType INAPP = new MessageType(Value.INAPP, "inapp"); - TWITTER("twitter"); + public static final MessageType TWITTER = new MessageType(Value.TWITTER, "twitter"); - private final String value; + private final Value value; - MessageType(String value) { + private final String string; + + MessageType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof MessageType && this.string.equals(((MessageType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case EMAIL: + return visitor.visitEmail(); + case FACEBOOK: + return visitor.visitFacebook(); + case INAPP: + return visitor.visitInapp(); + case TWITTER: + return visitor.visitTwitter(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static MessageType valueOf(String value) { + switch (value) { + case "email": + return EMAIL; + case "facebook": + return FACEBOOK; + case "inapp": + return INAPP; + case "twitter": + return TWITTER; + default: + return new MessageType(Value.UNKNOWN, value); + } + } + + public enum Value { + EMAIL, + + INAPP, + + FACEBOOK, + + TWITTER, + + UNKNOWN + } + + public interface Visitor { + T visitEmail(); + + T visitInapp(); + + T visitFacebook(); + + T visitTwitter(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/news/types/NewsItem.java b/src/main/java/com/intercom/api/resources/news/types/NewsItem.java index 26a9797..f9845f1 100644 --- a/src/main/java/com/intercom/api/resources/news/types/NewsItem.java +++ b/src/main/java/com/intercom/api/resources/news/types/NewsItem.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -564,21 +565,78 @@ public NewsItem build() { } } - public enum State { - DRAFT("draft"), + public static final class State { + public static final State LIVE = new State(Value.LIVE, "live"); - LIVE("live"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case LIVE: + return visitor.visitLive(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "live": + return LIVE; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + DRAFT, + + LIVE, + + UNKNOWN + } + + public interface Visitor { + T visitDraft(); + + T visitLive(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/segments/types/Segment.java b/src/main/java/com/intercom/api/resources/segments/types/Segment.java index 2a7fe65..3657dd5 100644 --- a/src/main/java/com/intercom/api/resources/segments/types/Segment.java +++ b/src/main/java/com/intercom/api/resources/segments/types/Segment.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -287,21 +288,78 @@ public Segment build() { } } - public enum PersonType { - CONTACT("contact"), + public static final class PersonType { + public static final PersonType USER = new PersonType(Value.USER, "user"); - USER("user"); + public static final PersonType CONTACT = new PersonType(Value.CONTACT, "contact"); - private final String value; + private final Value value; - PersonType(String value) { + private final String string; + + PersonType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof PersonType && this.string.equals(((PersonType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case USER: + return visitor.visitUser(); + case CONTACT: + return visitor.visitContact(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static PersonType valueOf(String value) { + switch (value) { + case "user": + return USER; + case "contact": + return CONTACT; + default: + return new PersonType(Value.UNKNOWN, value); + } + } + + public enum Value { + CONTACT, + + USER, + + UNKNOWN + } + + public interface Visitor { + T visitContact(); + + T visitUser(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/subscriptiontypes/types/SubscriptionType.java b/src/main/java/com/intercom/api/resources/subscriptiontypes/types/SubscriptionType.java index 4275506..eff4663 100644 --- a/src/main/java/com/intercom/api/resources/subscriptiontypes/types/SubscriptionType.java +++ b/src/main/java/com/intercom/api/resources/subscriptiontypes/types/SubscriptionType.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -311,59 +312,240 @@ public SubscriptionType build() { } } - public enum ConsentType { - OPT_OUT("opt_out"), + public static final class ConsentType { + public static final ConsentType OPT_IN = new ConsentType(Value.OPT_IN, "opt_in"); - OPT_IN("opt_in"); + public static final ConsentType OPT_OUT = new ConsentType(Value.OPT_OUT, "opt_out"); - private final String value; + private final Value value; - ConsentType(String value) { + private final String string; + + ConsentType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof ConsentType && this.string.equals(((ConsentType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case OPT_IN: + return visitor.visitOptIn(); + case OPT_OUT: + return visitor.visitOptOut(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ConsentType valueOf(String value) { + switch (value) { + case "opt_in": + return OPT_IN; + case "opt_out": + return OPT_OUT; + default: + return new ConsentType(Value.UNKNOWN, value); + } + } + + public enum Value { + OPT_OUT, + + OPT_IN, + + UNKNOWN + } + + public interface Visitor { + T visitOptOut(); + + T visitOptIn(); + + T visitUnknown(String unknownType); } } - public enum State { - LIVE("live"), + public static final class State { + public static final State LIVE = new State(Value.LIVE, "live"); - DRAFT("draft"), + public static final State ARCHIVED = new State(Value.ARCHIVED, "archived"); - ARCHIVED("archived"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case LIVE: + return visitor.visitLive(); + case ARCHIVED: + return visitor.visitArchived(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "live": + return LIVE; + case "archived": + return ARCHIVED; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + LIVE, + + DRAFT, + + ARCHIVED, + + UNKNOWN + } + + public interface Visitor { + T visitLive(); + + T visitDraft(); + + T visitArchived(); + + T visitUnknown(String unknownType); } } - public enum ContentTypesItem { - EMAIL("email"), + public static final class ContentTypesItem { + public static final ContentTypesItem EMAIL = new ContentTypesItem(Value.EMAIL, "email"); - SMS_MESSAGE("sms_message"); + public static final ContentTypesItem SMS_MESSAGE = new ContentTypesItem(Value.SMS_MESSAGE, "sms_message"); - private final String value; + private final Value value; - ContentTypesItem(String value) { + private final String string; + + ContentTypesItem(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof ContentTypesItem && this.string.equals(((ContentTypesItem) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case EMAIL: + return visitor.visitEmail(); + case SMS_MESSAGE: + return visitor.visitSmsMessage(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ContentTypesItem valueOf(String value) { + switch (value) { + case "email": + return EMAIL; + case "sms_message": + return SMS_MESSAGE; + default: + return new ContentTypesItem(Value.UNKNOWN, value); + } + } + + public enum Value { + EMAIL, + + SMS_MESSAGE, + + UNKNOWN + } + + public interface Visitor { + T visitEmail(); + + T visitSmsMessage(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/tickets/requests/UpdateTicketRequest.java b/src/main/java/com/intercom/api/resources/tickets/requests/UpdateTicketRequest.java index 06e3d92..5faf4bc 100644 --- a/src/main/java/com/intercom/api/resources/tickets/requests/UpdateTicketRequest.java +++ b/src/main/java/com/intercom/api/resources/tickets/requests/UpdateTicketRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -335,23 +336,88 @@ public UpdateTicketRequest build() { } } - public enum State { - IN_PROGRESS("in_progress"), + public static final class State { + public static final State IN_PROGRESS = new State(Value.IN_PROGRESS, "in_progress"); - WAITING_ON_CUSTOMER("waiting_on_customer"), + public static final State RESOLVED = new State(Value.RESOLVED, "resolved"); - RESOLVED("resolved"); + public static final State WAITING_ON_CUSTOMER = new State(Value.WAITING_ON_CUSTOMER, "waiting_on_customer"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case IN_PROGRESS: + return visitor.visitInProgress(); + case RESOLVED: + return visitor.visitResolved(); + case WAITING_ON_CUSTOMER: + return visitor.visitWaitingOnCustomer(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "in_progress": + return IN_PROGRESS; + case "resolved": + return RESOLVED; + case "waiting_on_customer": + return WAITING_ON_CUSTOMER; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + IN_PROGRESS, + + WAITING_ON_CUSTOMER, + + RESOLVED, + + UNKNOWN + } + + public interface Visitor { + T visitInProgress(); + + T visitWaitingOnCustomer(); + + T visitResolved(); + + T visitUnknown(String unknownType); } } diff --git a/src/main/java/com/intercom/api/resources/tickets/types/Ticket.java b/src/main/java/com/intercom/api/resources/tickets/types/Ticket.java index 308a85b..42d52dc 100644 --- a/src/main/java/com/intercom/api/resources/tickets/types/Ticket.java +++ b/src/main/java/com/intercom/api/resources/tickets/types/Ticket.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -740,45 +741,185 @@ public Ticket build() { } } - public enum TicketState { - SUBMITTED("submitted"), + public static final class TicketState { + public static final TicketState IN_PROGRESS = new TicketState(Value.IN_PROGRESS, "in_progress"); - IN_PROGRESS("in_progress"), + public static final TicketState SUBMITTED = new TicketState(Value.SUBMITTED, "submitted"); - WAITING_ON_CUSTOMER("waiting_on_customer"), + public static final TicketState RESOLVED = new TicketState(Value.RESOLVED, "resolved"); - RESOLVED("resolved"); + public static final TicketState WAITING_ON_CUSTOMER = + new TicketState(Value.WAITING_ON_CUSTOMER, "waiting_on_customer"); - private final String value; + private final Value value; - TicketState(String value) { + private final String string; + + TicketState(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof TicketState && this.string.equals(((TicketState) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case IN_PROGRESS: + return visitor.visitInProgress(); + case SUBMITTED: + return visitor.visitSubmitted(); + case RESOLVED: + return visitor.visitResolved(); + case WAITING_ON_CUSTOMER: + return visitor.visitWaitingOnCustomer(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static TicketState valueOf(String value) { + switch (value) { + case "in_progress": + return IN_PROGRESS; + case "submitted": + return SUBMITTED; + case "resolved": + return RESOLVED; + case "waiting_on_customer": + return WAITING_ON_CUSTOMER; + default: + return new TicketState(Value.UNKNOWN, value); + } + } + + public enum Value { + SUBMITTED, + + IN_PROGRESS, + + WAITING_ON_CUSTOMER, + + RESOLVED, + + UNKNOWN + } + + public interface Visitor { + T visitSubmitted(); + + T visitInProgress(); + + T visitWaitingOnCustomer(); + + T visitResolved(); + + T visitUnknown(String unknownType); } } - public enum Category { - CUSTOMER("Customer"), + public static final class Category { + public static final Category BACK_OFFICE = new Category(Value.BACK_OFFICE, "Back-office"); + + public static final Category CUSTOMER = new Category(Value.CUSTOMER, "Customer"); - BACK_OFFICE("Back-office"), + public static final Category TRACKER = new Category(Value.TRACKER, "Tracker"); - TRACKER("Tracker"); + private final Value value; - private final String value; + private final String string; - Category(String value) { + Category(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Category && this.string.equals(((Category) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case BACK_OFFICE: + return visitor.visitBackOffice(); + case CUSTOMER: + return visitor.visitCustomer(); + case TRACKER: + return visitor.visitTracker(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Category valueOf(String value) { + switch (value) { + case "Back-office": + return BACK_OFFICE; + case "Customer": + return CUSTOMER; + case "Tracker": + return TRACKER; + default: + return new Category(Value.UNKNOWN, value); + } + } + + public enum Value { + CUSTOMER, + + BACK_OFFICE, + + TRACKER, + + UNKNOWN + } + + public interface Visitor { + T visitCustomer(); + + T visitBackOffice(); + + T visitTracker(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/tickets/types/TicketPart.java b/src/main/java/com/intercom/api/resources/tickets/types/TicketPart.java index baaf919..77d5968 100644 --- a/src/main/java/com/intercom/api/resources/tickets/types/TicketPart.java +++ b/src/main/java/com/intercom/api/resources/tickets/types/TicketPart.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -531,47 +532,198 @@ public TicketPart build() { } } - public enum PreviousTicketState { - SUBMITTED("submitted"), + public static final class PreviousTicketState { + public static final PreviousTicketState IN_PROGRESS = new PreviousTicketState(Value.IN_PROGRESS, "in_progress"); - IN_PROGRESS("in_progress"), + public static final PreviousTicketState SUBMITTED = new PreviousTicketState(Value.SUBMITTED, "submitted"); - WAITING_ON_CUSTOMER("waiting_on_customer"), + public static final PreviousTicketState RESOLVED = new PreviousTicketState(Value.RESOLVED, "resolved"); - RESOLVED("resolved"); + public static final PreviousTicketState WAITING_ON_CUSTOMER = + new PreviousTicketState(Value.WAITING_ON_CUSTOMER, "waiting_on_customer"); - private final String value; + private final Value value; - PreviousTicketState(String value) { + private final String string; + + PreviousTicketState(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof PreviousTicketState + && this.string.equals(((PreviousTicketState) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case IN_PROGRESS: + return visitor.visitInProgress(); + case SUBMITTED: + return visitor.visitSubmitted(); + case RESOLVED: + return visitor.visitResolved(); + case WAITING_ON_CUSTOMER: + return visitor.visitWaitingOnCustomer(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static PreviousTicketState valueOf(String value) { + switch (value) { + case "in_progress": + return IN_PROGRESS; + case "submitted": + return SUBMITTED; + case "resolved": + return RESOLVED; + case "waiting_on_customer": + return WAITING_ON_CUSTOMER; + default: + return new PreviousTicketState(Value.UNKNOWN, value); + } + } + + public enum Value { + SUBMITTED, + + IN_PROGRESS, + + WAITING_ON_CUSTOMER, + + RESOLVED, + + UNKNOWN + } + + public interface Visitor { + T visitSubmitted(); + + T visitInProgress(); + + T visitWaitingOnCustomer(); + + T visitResolved(); + + T visitUnknown(String unknownType); } } - public enum TicketState { - SUBMITTED("submitted"), + public static final class TicketState { + public static final TicketState IN_PROGRESS = new TicketState(Value.IN_PROGRESS, "in_progress"); - IN_PROGRESS("in_progress"), + public static final TicketState SUBMITTED = new TicketState(Value.SUBMITTED, "submitted"); - WAITING_ON_CUSTOMER("waiting_on_customer"), + public static final TicketState RESOLVED = new TicketState(Value.RESOLVED, "resolved"); - RESOLVED("resolved"); + public static final TicketState WAITING_ON_CUSTOMER = + new TicketState(Value.WAITING_ON_CUSTOMER, "waiting_on_customer"); - private final String value; + private final Value value; - TicketState(String value) { + private final String string; + + TicketState(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof TicketState && this.string.equals(((TicketState) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case IN_PROGRESS: + return visitor.visitInProgress(); + case SUBMITTED: + return visitor.visitSubmitted(); + case RESOLVED: + return visitor.visitResolved(); + case WAITING_ON_CUSTOMER: + return visitor.visitWaitingOnCustomer(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static TicketState valueOf(String value) { + switch (value) { + case "in_progress": + return IN_PROGRESS; + case "submitted": + return SUBMITTED; + case "resolved": + return RESOLVED; + case "waiting_on_customer": + return WAITING_ON_CUSTOMER; + default: + return new TicketState(Value.UNKNOWN, value); + } + } + + public enum Value { + SUBMITTED, + + IN_PROGRESS, + + WAITING_ON_CUSTOMER, + + RESOLVED, + + UNKNOWN + } + + public interface Visitor { + T visitSubmitted(); + + T visitInProgress(); + + T visitWaitingOnCustomer(); + + T visitResolved(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/tickets/types/TicketType.java b/src/main/java/com/intercom/api/resources/tickets/types/TicketType.java index 51d2310..02e45f4 100644 --- a/src/main/java/com/intercom/api/resources/tickets/types/TicketType.java +++ b/src/main/java/com/intercom/api/resources/tickets/types/TicketType.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -431,23 +432,88 @@ public TicketType build() { } } - public enum Category { - CUSTOMER("Customer"), + public static final class Category { + public static final Category BACK_OFFICE = new Category(Value.BACK_OFFICE, "Back-office"); - BACK_OFFICE("Back-office"), + public static final Category CUSTOMER = new Category(Value.CUSTOMER, "Customer"); - TRACKER("Tracker"); + public static final Category TRACKER = new Category(Value.TRACKER, "Tracker"); - private final String value; + private final Value value; - Category(String value) { + private final String string; + + Category(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Category && this.string.equals(((Category) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case BACK_OFFICE: + return visitor.visitBackOffice(); + case CUSTOMER: + return visitor.visitCustomer(); + case TRACKER: + return visitor.visitTracker(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Category valueOf(String value) { + switch (value) { + case "Back-office": + return BACK_OFFICE; + case "Customer": + return CUSTOMER; + case "Tracker": + return TRACKER; + default: + return new Category(Value.UNKNOWN, value); + } + } + + public enum Value { + CUSTOMER, + + BACK_OFFICE, + + TRACKER, + + UNKNOWN + } + + public interface Visitor { + T visitCustomer(); + + T visitBackOffice(); + + T visitTracker(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/tickettypes/attributes/requests/CreateTicketTypeAttributeRequest.java b/src/main/java/com/intercom/api/resources/tickettypes/attributes/requests/CreateTicketTypeAttributeRequest.java index cdfce92..9d3c518 100644 --- a/src/main/java/com/intercom/api/resources/tickettypes/attributes/requests/CreateTicketTypeAttributeRequest.java +++ b/src/main/java/com/intercom/api/resources/tickettypes/attributes/requests/CreateTicketTypeAttributeRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -488,31 +489,128 @@ public CreateTicketTypeAttributeRequest build() { } } - public enum DataType { - STRING("string"), + public static final class DataType { + public static final DataType STRING = new DataType(Value.STRING, "string"); - LIST("list"), + public static final DataType DECIMAL = new DataType(Value.DECIMAL, "decimal"); - INTEGER("integer"), + public static final DataType LIST = new DataType(Value.LIST, "list"); - DECIMAL("decimal"), + public static final DataType INTEGER = new DataType(Value.INTEGER, "integer"); - BOOLEAN("boolean"), + public static final DataType DATETIME = new DataType(Value.DATETIME, "datetime"); - DATETIME("datetime"), + public static final DataType BOOLEAN = new DataType(Value.BOOLEAN, "boolean"); - FILES("files"); + public static final DataType FILES = new DataType(Value.FILES, "files"); - private final String value; + private final Value value; - DataType(String value) { + private final String string; + + DataType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof DataType && this.string.equals(((DataType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case STRING: + return visitor.visitString(); + case DECIMAL: + return visitor.visitDecimal(); + case LIST: + return visitor.visitList(); + case INTEGER: + return visitor.visitInteger(); + case DATETIME: + return visitor.visitDatetime(); + case BOOLEAN: + return visitor.visitBoolean(); + case FILES: + return visitor.visitFiles(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static DataType valueOf(String value) { + switch (value) { + case "string": + return STRING; + case "decimal": + return DECIMAL; + case "list": + return LIST; + case "integer": + return INTEGER; + case "datetime": + return DATETIME; + case "boolean": + return BOOLEAN; + case "files": + return FILES; + default: + return new DataType(Value.UNKNOWN, value); + } + } + + public enum Value { + STRING, + + LIST, + + INTEGER, + + DECIMAL, + + BOOLEAN, + + DATETIME, + + FILES, + + UNKNOWN + } + + public interface Visitor { + T visitString(); + + T visitList(); + + T visitInteger(); + + T visitDecimal(); + + T visitBoolean(); + + T visitDatetime(); + + T visitFiles(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/tickettypes/requests/CreateTicketTypeRequest.java b/src/main/java/com/intercom/api/resources/tickettypes/requests/CreateTicketTypeRequest.java index 9ef616e..08c7002 100644 --- a/src/main/java/com/intercom/api/resources/tickettypes/requests/CreateTicketTypeRequest.java +++ b/src/main/java/com/intercom/api/resources/tickettypes/requests/CreateTicketTypeRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -260,23 +261,88 @@ public CreateTicketTypeRequest build() { } } - public enum Category { - CUSTOMER("Customer"), + public static final class Category { + public static final Category BACK_OFFICE = new Category(Value.BACK_OFFICE, "Back-office"); - BACK_OFFICE("Back-office"), + public static final Category CUSTOMER = new Category(Value.CUSTOMER, "Customer"); - TRACKER("Tracker"); + public static final Category TRACKER = new Category(Value.TRACKER, "Tracker"); - private final String value; + private final Value value; - Category(String value) { + private final String string; + + Category(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Category && this.string.equals(((Category) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case BACK_OFFICE: + return visitor.visitBackOffice(); + case CUSTOMER: + return visitor.visitCustomer(); + case TRACKER: + return visitor.visitTracker(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Category valueOf(String value) { + switch (value) { + case "Back-office": + return BACK_OFFICE; + case "Customer": + return CUSTOMER; + case "Tracker": + return TRACKER; + default: + return new Category(Value.UNKNOWN, value); + } + } + + public enum Value { + CUSTOMER, + + BACK_OFFICE, + + TRACKER, + + UNKNOWN + } + + public interface Visitor { + T visitCustomer(); + + T visitBackOffice(); + + T visitTracker(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/resources/tickettypes/requests/UpdateTicketTypeRequest.java b/src/main/java/com/intercom/api/resources/tickettypes/requests/UpdateTicketTypeRequest.java index cdd28fc..ff8bbb5 100644 --- a/src/main/java/com/intercom/api/resources/tickettypes/requests/UpdateTicketTypeRequest.java +++ b/src/main/java/com/intercom/api/resources/tickettypes/requests/UpdateTicketTypeRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -342,23 +343,88 @@ public UpdateTicketTypeRequest build() { } } - public enum Category { - CUSTOMER("Customer"), + public static final class Category { + public static final Category BACK_OFFICE = new Category(Value.BACK_OFFICE, "Back-office"); - BACK_OFFICE("Back-office"), + public static final Category CUSTOMER = new Category(Value.CUSTOMER, "Customer"); - TRACKER("Tracker"); + public static final Category TRACKER = new Category(Value.TRACKER, "Tracker"); - private final String value; + private final Value value; - Category(String value) { + private final String string; + + Category(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Category && this.string.equals(((Category) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case BACK_OFFICE: + return visitor.visitBackOffice(); + case CUSTOMER: + return visitor.visitCustomer(); + case TRACKER: + return visitor.visitTracker(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Category valueOf(String value) { + switch (value) { + case "Back-office": + return BACK_OFFICE; + case "Customer": + return CUSTOMER; + case "Tracker": + return TRACKER; + default: + return new Category(Value.UNKNOWN, value); + } + } + + public enum Value { + CUSTOMER, + + BACK_OFFICE, + + TRACKER, + + UNKNOWN + } + + public interface Visitor { + T visitCustomer(); + + T visitBackOffice(); + + T visitTracker(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/ActivityLog.java b/src/main/java/com/intercom/api/types/ActivityLog.java index e3918cf..4ec026f 100644 --- a/src/main/java/com/intercom/api/types/ActivityLog.java +++ b/src/main/java/com/intercom/api/types/ActivityLog.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -433,151 +434,784 @@ public PerformedBy build() { } } - public enum ActivityType { - ADMIN_ASSIGNMENT_LIMIT_CHANGE("admin_assignment_limit_change"), + public static final class ActivityType { + public static final ActivityType CAMPAIGN_DELETION = + new ActivityType(Value.CAMPAIGN_DELETION, "campaign_deletion"); - ADMIN_AWAY_MODE_CHANGE("admin_away_mode_change"), + public static final ActivityType ADMIN_LOGOUT = new ActivityType(Value.ADMIN_LOGOUT, "admin_logout"); - ADMIN_DELETION("admin_deletion"), + public static final ActivityType TEMPORARY_EXPECTATION_CHANGE = + new ActivityType(Value.TEMPORARY_EXPECTATION_CHANGE, "temporary_expectation_change"); - ADMIN_DEPROVISIONED("admin_deprovisioned"), + public static final ActivityType ADMIN_IMPERSONATION_END = + new ActivityType(Value.ADMIN_IMPERSONATION_END, "admin_impersonation_end"); - ADMIN_IMPERSONATION_END("admin_impersonation_end"), + public static final ActivityType APP_OUTBOUND_ADDRESS_CHANGE = + new ActivityType(Value.APP_OUTBOUND_ADDRESS_CHANGE, "app_outbound_address_change"); - ADMIN_IMPERSONATION_START("admin_impersonation_start"), + public static final ActivityType SEAT_CHANGE = new ActivityType(Value.SEAT_CHANGE, "seat_change"); - ADMIN_INVITE_CHANGE("admin_invite_change"), + public static final ActivityType SEARCH_BROWSE_REQUIRED_CHANGE = + new ActivityType(Value.SEARCH_BROWSE_REQUIRED_CHANGE, "search_browse_required_change"); - ADMIN_INVITE_CREATION("admin_invite_creation"), + public static final ActivityType SECURITY_SETTINGS_CHANGE = + new ActivityType(Value.SECURITY_SETTINGS_CHANGE, "security_settings_change"); - ADMIN_INVITE_DELETION("admin_invite_deletion"), + public static final ActivityType APP_TEAM_CREATION = + new ActivityType(Value.APP_TEAM_CREATION, "app_team_creation"); - ADMIN_LOGIN_FAILURE("admin_login_failure"), + public static final ActivityType APP_PACKAGE_UNINSTALLATION = + new ActivityType(Value.APP_PACKAGE_UNINSTALLATION, "app_package_uninstallation"); - ADMIN_LOGIN_SUCCESS("admin_login_success"), + public static final ActivityType CONVERSATION_TOPIC_CHANGE = + new ActivityType(Value.CONVERSATION_TOPIC_CHANGE, "conversation_topic_change"); - ADMIN_LOGOUT("admin_logout"), + public static final ActivityType ADMIN_ASSIGNMENT_LIMIT_CHANGE = + new ActivityType(Value.ADMIN_ASSIGNMENT_LIMIT_CHANGE, "admin_assignment_limit_change"); - ADMIN_PASSWORD_RESET_REQUEST("admin_password_reset_request"), + public static final ActivityType CAMPAIGN_STATE_CHANGE = + new ActivityType(Value.CAMPAIGN_STATE_CHANGE, "campaign_state_change"); - ADMIN_PASSWORD_RESET_SUCCESS("admin_password_reset_success"), + public static final ActivityType ADMIN_AWAY_MODE_CHANGE = + new ActivityType(Value.ADMIN_AWAY_MODE_CHANGE, "admin_away_mode_change"); - ADMIN_PERMISSION_CHANGE("admin_permission_change"), + public static final ActivityType CONVERSATION_PART_DELETION = + new ActivityType(Value.CONVERSATION_PART_DELETION, "conversation_part_deletion"); - ADMIN_PROVISIONED("admin_provisioned"), + public static final ActivityType APP_WEBHOOK_DELETION = + new ActivityType(Value.APP_WEBHOOK_DELETION, "app_webhook_deletion"); - ADMIN_TWO_FACTOR_AUTH_CHANGE("admin_two_factor_auth_change"), + public static final ActivityType SEARCH_BROWSE_ENABLED_CHANGE = + new ActivityType(Value.SEARCH_BROWSE_ENABLED_CHANGE, "search_browse_enabled_change"); - ADMIN_UNAUTHORIZED_SIGN_IN_METHOD("admin_unauthorized_sign_in_method"), + public static final ActivityType MESSENGER_SEARCH_REQUIRED_CHANGE = + new ActivityType(Value.MESSENGER_SEARCH_REQUIRED_CHANGE, "messenger_search_required_change"); - APP_ADMIN_JOIN("app_admin_join"), + public static final ActivityType ADMIN_DEPROVISIONED = + new ActivityType(Value.ADMIN_DEPROVISIONED, "admin_deprovisioned"); - APP_AUTHENTICATION_METHOD_CHANGE("app_authentication_method_change"), + public static final ActivityType APP_AUTHENTICATION_METHOD_CHANGE = + new ActivityType(Value.APP_AUTHENTICATION_METHOD_CHANGE, "app_authentication_method_change"); - APP_DATA_DELETION("app_data_deletion"), + public static final ActivityType RULESET_CREATION = + new ActivityType(Value.RULESET_CREATION, "ruleset_creation"); - APP_DATA_EXPORT("app_data_export"), + public static final ActivityType ADMIN_DELETION = new ActivityType(Value.ADMIN_DELETION, "admin_deletion"); - APP_GOOGLE_SSO_DOMAIN_CHANGE("app_google_sso_domain_change"), + public static final ActivityType APP_PACKAGE_INSTALLATION = + new ActivityType(Value.APP_PACKAGE_INSTALLATION, "app_package_installation"); - APP_IDENTITY_VERIFICATION_CHANGE("app_identity_verification_change"), + public static final ActivityType ROLE_CREATION = new ActivityType(Value.ROLE_CREATION, "role_creation"); - APP_NAME_CHANGE("app_name_change"), + public static final ActivityType APP_ADMIN_JOIN = new ActivityType(Value.APP_ADMIN_JOIN, "app_admin_join"); - APP_OUTBOUND_ADDRESS_CHANGE("app_outbound_address_change"), + public static final ActivityType APP_DATA_EXPORT = new ActivityType(Value.APP_DATA_EXPORT, "app_data_export"); - APP_PACKAGE_INSTALLATION("app_package_installation"), + public static final ActivityType ADMIN_LOGIN_FAILURE = + new ActivityType(Value.ADMIN_LOGIN_FAILURE, "admin_login_failure"); - APP_PACKAGE_TOKEN_REGENERATION("app_package_token_regeneration"), + public static final ActivityType APP_TEAM_DELETION = + new ActivityType(Value.APP_TEAM_DELETION, "app_team_deletion"); - APP_PACKAGE_UNINSTALLATION("app_package_uninstallation"), + public static final ActivityType MESSENGER_LOOK_AND_FEEL_CHANGE = + new ActivityType(Value.MESSENGER_LOOK_AND_FEEL_CHANGE, "messenger_look_and_feel_change"); - APP_TEAM_CREATION("app_team_creation"), + public static final ActivityType SEAT_REVOKE = new ActivityType(Value.SEAT_REVOKE, "seat_revoke"); - APP_TEAM_DELETION("app_team_deletion"), + public static final ActivityType RULESET_ACTIVATION_TITLE_PREVIEW = + new ActivityType(Value.RULESET_ACTIVATION_TITLE_PREVIEW, "ruleset_activation_title_preview"); - APP_TEAM_MEMBERSHIP_MODIFICATION("app_team_membership_modification"), + public static final ActivityType MESSAGE_DELETION = + new ActivityType(Value.MESSAGE_DELETION, "message_deletion"); - APP_TIMEZONE_CHANGE("app_timezone_change"), + public static final ActivityType MESSENGER_SPACES_CHANGE = + new ActivityType(Value.MESSENGER_SPACES_CHANGE, "messenger_spaces_change"); - APP_WEBHOOK_CREATION("app_webhook_creation"), + public static final ActivityType APP_NAME_CHANGE = new ActivityType(Value.APP_NAME_CHANGE, "app_name_change"); - APP_WEBHOOK_DELETION("app_webhook_deletion"), + public static final ActivityType APP_WEBHOOK_CREATION = + new ActivityType(Value.APP_WEBHOOK_CREATION, "app_webhook_creation"); - ARTICLES_IN_MESSENGER_ENABLED_CHANGE("articles_in_messenger_enabled_change"), + public static final ActivityType APP_GOOGLE_SSO_DOMAIN_CHANGE = + new ActivityType(Value.APP_GOOGLE_SSO_DOMAIN_CHANGE, "app_google_sso_domain_change"); - BULK_DELETE("bulk_delete"), + public static final ActivityType CONVERSATION_TOPIC_CREATION = + new ActivityType(Value.CONVERSATION_TOPIC_CREATION, "conversation_topic_creation"); - BULK_EXPORT("bulk_export"), + public static final ActivityType HELP_CENTER_SETTINGS_CHANGE = + new ActivityType(Value.HELP_CENTER_SETTINGS_CHANGE, "help_center_settings_change"); - CAMPAIGN_DELETION("campaign_deletion"), + public static final ActivityType ROLE_DELETION = new ActivityType(Value.ROLE_DELETION, "role_deletion"); - CAMPAIGN_STATE_CHANGE("campaign_state_change"), + public static final ActivityType APP_PACKAGE_TOKEN_REGENERATION = + new ActivityType(Value.APP_PACKAGE_TOKEN_REGENERATION, "app_package_token_regeneration"); - CONVERSATION_PART_DELETION("conversation_part_deletion"), + public static final ActivityType APP_TIMEZONE_CHANGE = + new ActivityType(Value.APP_TIMEZONE_CHANGE, "app_timezone_change"); - CONVERSATION_TOPIC_CHANGE("conversation_topic_change"), + public static final ActivityType ROLE_CHANGE = new ActivityType(Value.ROLE_CHANGE, "role_change"); - CONVERSATION_TOPIC_CREATION("conversation_topic_creation"), + public static final ActivityType ADMIN_IMPERSONATION_START = + new ActivityType(Value.ADMIN_IMPERSONATION_START, "admin_impersonation_start"); - CONVERSATION_TOPIC_DELETION("conversation_topic_deletion"), + public static final ActivityType BULK_DELETE = new ActivityType(Value.BULK_DELETE, "bulk_delete"); - HELP_CENTER_SETTINGS_CHANGE("help_center_settings_change"), + public static final ActivityType ADMIN_INVITE_DELETION = + new ActivityType(Value.ADMIN_INVITE_DELETION, "admin_invite_deletion"); - INBOUND_CONVERSATIONS_CHANGE("inbound_conversations_change"), + public static final ActivityType ADMIN_PASSWORD_RESET_REQUEST = + new ActivityType(Value.ADMIN_PASSWORD_RESET_REQUEST, "admin_password_reset_request"); - INBOX_ACCESS_CHANGE("inbox_access_change"), + public static final ActivityType APP_DATA_DELETION = + new ActivityType(Value.APP_DATA_DELETION, "app_data_deletion"); - MESSAGE_DELETION("message_deletion"), + public static final ActivityType APP_IDENTITY_VERIFICATION_CHANGE = + new ActivityType(Value.APP_IDENTITY_VERIFICATION_CHANGE, "app_identity_verification_change"); - MESSAGE_STATE_CHANGE("message_state_change"), + public static final ActivityType CONVERSATION_TOPIC_DELETION = + new ActivityType(Value.CONVERSATION_TOPIC_DELETION, "conversation_topic_deletion"); - MESSENGER_LOOK_AND_FEEL_CHANGE("messenger_look_and_feel_change"), + public static final ActivityType ADMIN_PASSWORD_RESET_SUCCESS = + new ActivityType(Value.ADMIN_PASSWORD_RESET_SUCCESS, "admin_password_reset_success"); - MESSENGER_SEARCH_REQUIRED_CHANGE("messenger_search_required_change"), + public static final ActivityType OFFICE_HOURS_CHANGE = + new ActivityType(Value.OFFICE_HOURS_CHANGE, "office_hours_change"); - MESSENGER_SPACES_CHANGE("messenger_spaces_change"), + public static final ActivityType ADMIN_UNAUTHORIZED_SIGN_IN_METHOD = + new ActivityType(Value.ADMIN_UNAUTHORIZED_SIGN_IN_METHOD, "admin_unauthorized_sign_in_method"); - OFFICE_HOURS_CHANGE("office_hours_change"), + public static final ActivityType BULK_EXPORT = new ActivityType(Value.BULK_EXPORT, "bulk_export"); - ROLE_CHANGE("role_change"), + public static final ActivityType WELCOME_MESSAGE_CHANGE = + new ActivityType(Value.WELCOME_MESSAGE_CHANGE, "welcome_message_change"); - ROLE_CREATION("role_creation"), + public static final ActivityType ADMIN_PROVISIONED = + new ActivityType(Value.ADMIN_PROVISIONED, "admin_provisioned"); - ROLE_DELETION("role_deletion"), + public static final ActivityType UPFRONT_EMAIL_COLLECTION_CHANGE = + new ActivityType(Value.UPFRONT_EMAIL_COLLECTION_CHANGE, "upfront_email_collection_change"); - RULESET_ACTIVATION_TITLE_PREVIEW("ruleset_activation_title_preview"), + public static final ActivityType ARTICLES_IN_MESSENGER_ENABLED_CHANGE = + new ActivityType(Value.ARTICLES_IN_MESSENGER_ENABLED_CHANGE, "articles_in_messenger_enabled_change"); - RULESET_CREATION("ruleset_creation"), + public static final ActivityType ADMIN_LOGIN_SUCCESS = + new ActivityType(Value.ADMIN_LOGIN_SUCCESS, "admin_login_success"); - RULESET_DELETION("ruleset_deletion"), + public static final ActivityType ADMIN_TWO_FACTOR_AUTH_CHANGE = + new ActivityType(Value.ADMIN_TWO_FACTOR_AUTH_CHANGE, "admin_two_factor_auth_change"); - SEARCH_BROWSE_ENABLED_CHANGE("search_browse_enabled_change"), + public static final ActivityType APP_TEAM_MEMBERSHIP_MODIFICATION = + new ActivityType(Value.APP_TEAM_MEMBERSHIP_MODIFICATION, "app_team_membership_modification"); - SEARCH_BROWSE_REQUIRED_CHANGE("search_browse_required_change"), + public static final ActivityType ADMIN_PERMISSION_CHANGE = + new ActivityType(Value.ADMIN_PERMISSION_CHANGE, "admin_permission_change"); - SEAT_CHANGE("seat_change"), + public static final ActivityType INBOUND_CONVERSATIONS_CHANGE = + new ActivityType(Value.INBOUND_CONVERSATIONS_CHANGE, "inbound_conversations_change"); - SEAT_REVOKE("seat_revoke"), + public static final ActivityType MESSAGE_STATE_CHANGE = + new ActivityType(Value.MESSAGE_STATE_CHANGE, "message_state_change"); - SECURITY_SETTINGS_CHANGE("security_settings_change"), + public static final ActivityType ADMIN_INVITE_CREATION = + new ActivityType(Value.ADMIN_INVITE_CREATION, "admin_invite_creation"); - TEMPORARY_EXPECTATION_CHANGE("temporary_expectation_change"), + public static final ActivityType INBOX_ACCESS_CHANGE = + new ActivityType(Value.INBOX_ACCESS_CHANGE, "inbox_access_change"); - UPFRONT_EMAIL_COLLECTION_CHANGE("upfront_email_collection_change"), + public static final ActivityType ADMIN_INVITE_CHANGE = + new ActivityType(Value.ADMIN_INVITE_CHANGE, "admin_invite_change"); - WELCOME_MESSAGE_CHANGE("welcome_message_change"); + public static final ActivityType RULESET_DELETION = + new ActivityType(Value.RULESET_DELETION, "ruleset_deletion"); - private final String value; + private final Value value; - ActivityType(String value) { + private final String string; + + ActivityType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof ActivityType && this.string.equals(((ActivityType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case CAMPAIGN_DELETION: + return visitor.visitCampaignDeletion(); + case ADMIN_LOGOUT: + return visitor.visitAdminLogout(); + case TEMPORARY_EXPECTATION_CHANGE: + return visitor.visitTemporaryExpectationChange(); + case ADMIN_IMPERSONATION_END: + return visitor.visitAdminImpersonationEnd(); + case APP_OUTBOUND_ADDRESS_CHANGE: + return visitor.visitAppOutboundAddressChange(); + case SEAT_CHANGE: + return visitor.visitSeatChange(); + case SEARCH_BROWSE_REQUIRED_CHANGE: + return visitor.visitSearchBrowseRequiredChange(); + case SECURITY_SETTINGS_CHANGE: + return visitor.visitSecuritySettingsChange(); + case APP_TEAM_CREATION: + return visitor.visitAppTeamCreation(); + case APP_PACKAGE_UNINSTALLATION: + return visitor.visitAppPackageUninstallation(); + case CONVERSATION_TOPIC_CHANGE: + return visitor.visitConversationTopicChange(); + case ADMIN_ASSIGNMENT_LIMIT_CHANGE: + return visitor.visitAdminAssignmentLimitChange(); + case CAMPAIGN_STATE_CHANGE: + return visitor.visitCampaignStateChange(); + case ADMIN_AWAY_MODE_CHANGE: + return visitor.visitAdminAwayModeChange(); + case CONVERSATION_PART_DELETION: + return visitor.visitConversationPartDeletion(); + case APP_WEBHOOK_DELETION: + return visitor.visitAppWebhookDeletion(); + case SEARCH_BROWSE_ENABLED_CHANGE: + return visitor.visitSearchBrowseEnabledChange(); + case MESSENGER_SEARCH_REQUIRED_CHANGE: + return visitor.visitMessengerSearchRequiredChange(); + case ADMIN_DEPROVISIONED: + return visitor.visitAdminDeprovisioned(); + case APP_AUTHENTICATION_METHOD_CHANGE: + return visitor.visitAppAuthenticationMethodChange(); + case RULESET_CREATION: + return visitor.visitRulesetCreation(); + case ADMIN_DELETION: + return visitor.visitAdminDeletion(); + case APP_PACKAGE_INSTALLATION: + return visitor.visitAppPackageInstallation(); + case ROLE_CREATION: + return visitor.visitRoleCreation(); + case APP_ADMIN_JOIN: + return visitor.visitAppAdminJoin(); + case APP_DATA_EXPORT: + return visitor.visitAppDataExport(); + case ADMIN_LOGIN_FAILURE: + return visitor.visitAdminLoginFailure(); + case APP_TEAM_DELETION: + return visitor.visitAppTeamDeletion(); + case MESSENGER_LOOK_AND_FEEL_CHANGE: + return visitor.visitMessengerLookAndFeelChange(); + case SEAT_REVOKE: + return visitor.visitSeatRevoke(); + case RULESET_ACTIVATION_TITLE_PREVIEW: + return visitor.visitRulesetActivationTitlePreview(); + case MESSAGE_DELETION: + return visitor.visitMessageDeletion(); + case MESSENGER_SPACES_CHANGE: + return visitor.visitMessengerSpacesChange(); + case APP_NAME_CHANGE: + return visitor.visitAppNameChange(); + case APP_WEBHOOK_CREATION: + return visitor.visitAppWebhookCreation(); + case APP_GOOGLE_SSO_DOMAIN_CHANGE: + return visitor.visitAppGoogleSsoDomainChange(); + case CONVERSATION_TOPIC_CREATION: + return visitor.visitConversationTopicCreation(); + case HELP_CENTER_SETTINGS_CHANGE: + return visitor.visitHelpCenterSettingsChange(); + case ROLE_DELETION: + return visitor.visitRoleDeletion(); + case APP_PACKAGE_TOKEN_REGENERATION: + return visitor.visitAppPackageTokenRegeneration(); + case APP_TIMEZONE_CHANGE: + return visitor.visitAppTimezoneChange(); + case ROLE_CHANGE: + return visitor.visitRoleChange(); + case ADMIN_IMPERSONATION_START: + return visitor.visitAdminImpersonationStart(); + case BULK_DELETE: + return visitor.visitBulkDelete(); + case ADMIN_INVITE_DELETION: + return visitor.visitAdminInviteDeletion(); + case ADMIN_PASSWORD_RESET_REQUEST: + return visitor.visitAdminPasswordResetRequest(); + case APP_DATA_DELETION: + return visitor.visitAppDataDeletion(); + case APP_IDENTITY_VERIFICATION_CHANGE: + return visitor.visitAppIdentityVerificationChange(); + case CONVERSATION_TOPIC_DELETION: + return visitor.visitConversationTopicDeletion(); + case ADMIN_PASSWORD_RESET_SUCCESS: + return visitor.visitAdminPasswordResetSuccess(); + case OFFICE_HOURS_CHANGE: + return visitor.visitOfficeHoursChange(); + case ADMIN_UNAUTHORIZED_SIGN_IN_METHOD: + return visitor.visitAdminUnauthorizedSignInMethod(); + case BULK_EXPORT: + return visitor.visitBulkExport(); + case WELCOME_MESSAGE_CHANGE: + return visitor.visitWelcomeMessageChange(); + case ADMIN_PROVISIONED: + return visitor.visitAdminProvisioned(); + case UPFRONT_EMAIL_COLLECTION_CHANGE: + return visitor.visitUpfrontEmailCollectionChange(); + case ARTICLES_IN_MESSENGER_ENABLED_CHANGE: + return visitor.visitArticlesInMessengerEnabledChange(); + case ADMIN_LOGIN_SUCCESS: + return visitor.visitAdminLoginSuccess(); + case ADMIN_TWO_FACTOR_AUTH_CHANGE: + return visitor.visitAdminTwoFactorAuthChange(); + case APP_TEAM_MEMBERSHIP_MODIFICATION: + return visitor.visitAppTeamMembershipModification(); + case ADMIN_PERMISSION_CHANGE: + return visitor.visitAdminPermissionChange(); + case INBOUND_CONVERSATIONS_CHANGE: + return visitor.visitInboundConversationsChange(); + case MESSAGE_STATE_CHANGE: + return visitor.visitMessageStateChange(); + case ADMIN_INVITE_CREATION: + return visitor.visitAdminInviteCreation(); + case INBOX_ACCESS_CHANGE: + return visitor.visitInboxAccessChange(); + case ADMIN_INVITE_CHANGE: + return visitor.visitAdminInviteChange(); + case RULESET_DELETION: + return visitor.visitRulesetDeletion(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static ActivityType valueOf(String value) { + switch (value) { + case "campaign_deletion": + return CAMPAIGN_DELETION; + case "admin_logout": + return ADMIN_LOGOUT; + case "temporary_expectation_change": + return TEMPORARY_EXPECTATION_CHANGE; + case "admin_impersonation_end": + return ADMIN_IMPERSONATION_END; + case "app_outbound_address_change": + return APP_OUTBOUND_ADDRESS_CHANGE; + case "seat_change": + return SEAT_CHANGE; + case "search_browse_required_change": + return SEARCH_BROWSE_REQUIRED_CHANGE; + case "security_settings_change": + return SECURITY_SETTINGS_CHANGE; + case "app_team_creation": + return APP_TEAM_CREATION; + case "app_package_uninstallation": + return APP_PACKAGE_UNINSTALLATION; + case "conversation_topic_change": + return CONVERSATION_TOPIC_CHANGE; + case "admin_assignment_limit_change": + return ADMIN_ASSIGNMENT_LIMIT_CHANGE; + case "campaign_state_change": + return CAMPAIGN_STATE_CHANGE; + case "admin_away_mode_change": + return ADMIN_AWAY_MODE_CHANGE; + case "conversation_part_deletion": + return CONVERSATION_PART_DELETION; + case "app_webhook_deletion": + return APP_WEBHOOK_DELETION; + case "search_browse_enabled_change": + return SEARCH_BROWSE_ENABLED_CHANGE; + case "messenger_search_required_change": + return MESSENGER_SEARCH_REQUIRED_CHANGE; + case "admin_deprovisioned": + return ADMIN_DEPROVISIONED; + case "app_authentication_method_change": + return APP_AUTHENTICATION_METHOD_CHANGE; + case "ruleset_creation": + return RULESET_CREATION; + case "admin_deletion": + return ADMIN_DELETION; + case "app_package_installation": + return APP_PACKAGE_INSTALLATION; + case "role_creation": + return ROLE_CREATION; + case "app_admin_join": + return APP_ADMIN_JOIN; + case "app_data_export": + return APP_DATA_EXPORT; + case "admin_login_failure": + return ADMIN_LOGIN_FAILURE; + case "app_team_deletion": + return APP_TEAM_DELETION; + case "messenger_look_and_feel_change": + return MESSENGER_LOOK_AND_FEEL_CHANGE; + case "seat_revoke": + return SEAT_REVOKE; + case "ruleset_activation_title_preview": + return RULESET_ACTIVATION_TITLE_PREVIEW; + case "message_deletion": + return MESSAGE_DELETION; + case "messenger_spaces_change": + return MESSENGER_SPACES_CHANGE; + case "app_name_change": + return APP_NAME_CHANGE; + case "app_webhook_creation": + return APP_WEBHOOK_CREATION; + case "app_google_sso_domain_change": + return APP_GOOGLE_SSO_DOMAIN_CHANGE; + case "conversation_topic_creation": + return CONVERSATION_TOPIC_CREATION; + case "help_center_settings_change": + return HELP_CENTER_SETTINGS_CHANGE; + case "role_deletion": + return ROLE_DELETION; + case "app_package_token_regeneration": + return APP_PACKAGE_TOKEN_REGENERATION; + case "app_timezone_change": + return APP_TIMEZONE_CHANGE; + case "role_change": + return ROLE_CHANGE; + case "admin_impersonation_start": + return ADMIN_IMPERSONATION_START; + case "bulk_delete": + return BULK_DELETE; + case "admin_invite_deletion": + return ADMIN_INVITE_DELETION; + case "admin_password_reset_request": + return ADMIN_PASSWORD_RESET_REQUEST; + case "app_data_deletion": + return APP_DATA_DELETION; + case "app_identity_verification_change": + return APP_IDENTITY_VERIFICATION_CHANGE; + case "conversation_topic_deletion": + return CONVERSATION_TOPIC_DELETION; + case "admin_password_reset_success": + return ADMIN_PASSWORD_RESET_SUCCESS; + case "office_hours_change": + return OFFICE_HOURS_CHANGE; + case "admin_unauthorized_sign_in_method": + return ADMIN_UNAUTHORIZED_SIGN_IN_METHOD; + case "bulk_export": + return BULK_EXPORT; + case "welcome_message_change": + return WELCOME_MESSAGE_CHANGE; + case "admin_provisioned": + return ADMIN_PROVISIONED; + case "upfront_email_collection_change": + return UPFRONT_EMAIL_COLLECTION_CHANGE; + case "articles_in_messenger_enabled_change": + return ARTICLES_IN_MESSENGER_ENABLED_CHANGE; + case "admin_login_success": + return ADMIN_LOGIN_SUCCESS; + case "admin_two_factor_auth_change": + return ADMIN_TWO_FACTOR_AUTH_CHANGE; + case "app_team_membership_modification": + return APP_TEAM_MEMBERSHIP_MODIFICATION; + case "admin_permission_change": + return ADMIN_PERMISSION_CHANGE; + case "inbound_conversations_change": + return INBOUND_CONVERSATIONS_CHANGE; + case "message_state_change": + return MESSAGE_STATE_CHANGE; + case "admin_invite_creation": + return ADMIN_INVITE_CREATION; + case "inbox_access_change": + return INBOX_ACCESS_CHANGE; + case "admin_invite_change": + return ADMIN_INVITE_CHANGE; + case "ruleset_deletion": + return RULESET_DELETION; + default: + return new ActivityType(Value.UNKNOWN, value); + } + } + + public enum Value { + ADMIN_ASSIGNMENT_LIMIT_CHANGE, + + ADMIN_AWAY_MODE_CHANGE, + + ADMIN_DELETION, + + ADMIN_DEPROVISIONED, + + ADMIN_IMPERSONATION_END, + + ADMIN_IMPERSONATION_START, + + ADMIN_INVITE_CHANGE, + + ADMIN_INVITE_CREATION, + + ADMIN_INVITE_DELETION, + + ADMIN_LOGIN_FAILURE, + + ADMIN_LOGIN_SUCCESS, + + ADMIN_LOGOUT, + + ADMIN_PASSWORD_RESET_REQUEST, + + ADMIN_PASSWORD_RESET_SUCCESS, + + ADMIN_PERMISSION_CHANGE, + + ADMIN_PROVISIONED, + + ADMIN_TWO_FACTOR_AUTH_CHANGE, + + ADMIN_UNAUTHORIZED_SIGN_IN_METHOD, + + APP_ADMIN_JOIN, + + APP_AUTHENTICATION_METHOD_CHANGE, + + APP_DATA_DELETION, + + APP_DATA_EXPORT, + + APP_GOOGLE_SSO_DOMAIN_CHANGE, + + APP_IDENTITY_VERIFICATION_CHANGE, + + APP_NAME_CHANGE, + + APP_OUTBOUND_ADDRESS_CHANGE, + + APP_PACKAGE_INSTALLATION, + + APP_PACKAGE_TOKEN_REGENERATION, + + APP_PACKAGE_UNINSTALLATION, + + APP_TEAM_CREATION, + + APP_TEAM_DELETION, + + APP_TEAM_MEMBERSHIP_MODIFICATION, + + APP_TIMEZONE_CHANGE, + + APP_WEBHOOK_CREATION, + + APP_WEBHOOK_DELETION, + + ARTICLES_IN_MESSENGER_ENABLED_CHANGE, + + BULK_DELETE, + + BULK_EXPORT, + + CAMPAIGN_DELETION, + + CAMPAIGN_STATE_CHANGE, + + CONVERSATION_PART_DELETION, + + CONVERSATION_TOPIC_CHANGE, + + CONVERSATION_TOPIC_CREATION, + + CONVERSATION_TOPIC_DELETION, + + HELP_CENTER_SETTINGS_CHANGE, + + INBOUND_CONVERSATIONS_CHANGE, + + INBOX_ACCESS_CHANGE, + + MESSAGE_DELETION, + + MESSAGE_STATE_CHANGE, + + MESSENGER_LOOK_AND_FEEL_CHANGE, + + MESSENGER_SEARCH_REQUIRED_CHANGE, + + MESSENGER_SPACES_CHANGE, + + OFFICE_HOURS_CHANGE, + + ROLE_CHANGE, + + ROLE_CREATION, + + ROLE_DELETION, + + RULESET_ACTIVATION_TITLE_PREVIEW, + + RULESET_CREATION, + + RULESET_DELETION, + + SEARCH_BROWSE_ENABLED_CHANGE, + + SEARCH_BROWSE_REQUIRED_CHANGE, + + SEAT_CHANGE, + + SEAT_REVOKE, + + SECURITY_SETTINGS_CHANGE, + + TEMPORARY_EXPECTATION_CHANGE, + + UPFRONT_EMAIL_COLLECTION_CHANGE, + + WELCOME_MESSAGE_CHANGE, + + UNKNOWN + } + + public interface Visitor { + T visitAdminAssignmentLimitChange(); + + T visitAdminAwayModeChange(); + + T visitAdminDeletion(); + + T visitAdminDeprovisioned(); + + T visitAdminImpersonationEnd(); + + T visitAdminImpersonationStart(); + + T visitAdminInviteChange(); + + T visitAdminInviteCreation(); + + T visitAdminInviteDeletion(); + + T visitAdminLoginFailure(); + + T visitAdminLoginSuccess(); + + T visitAdminLogout(); + + T visitAdminPasswordResetRequest(); + + T visitAdminPasswordResetSuccess(); + + T visitAdminPermissionChange(); + + T visitAdminProvisioned(); + + T visitAdminTwoFactorAuthChange(); + + T visitAdminUnauthorizedSignInMethod(); + + T visitAppAdminJoin(); + + T visitAppAuthenticationMethodChange(); + + T visitAppDataDeletion(); + + T visitAppDataExport(); + + T visitAppGoogleSsoDomainChange(); + + T visitAppIdentityVerificationChange(); + + T visitAppNameChange(); + + T visitAppOutboundAddressChange(); + + T visitAppPackageInstallation(); + + T visitAppPackageTokenRegeneration(); + + T visitAppPackageUninstallation(); + + T visitAppTeamCreation(); + + T visitAppTeamDeletion(); + + T visitAppTeamMembershipModification(); + + T visitAppTimezoneChange(); + + T visitAppWebhookCreation(); + + T visitAppWebhookDeletion(); + + T visitArticlesInMessengerEnabledChange(); + + T visitBulkDelete(); + + T visitBulkExport(); + + T visitCampaignDeletion(); + + T visitCampaignStateChange(); + + T visitConversationPartDeletion(); + + T visitConversationTopicChange(); + + T visitConversationTopicCreation(); + + T visitConversationTopicDeletion(); + + T visitHelpCenterSettingsChange(); + + T visitInboundConversationsChange(); + + T visitInboxAccessChange(); + + T visitMessageDeletion(); + + T visitMessageStateChange(); + + T visitMessengerLookAndFeelChange(); + + T visitMessengerSearchRequiredChange(); + + T visitMessengerSpacesChange(); + + T visitOfficeHoursChange(); + + T visitRoleChange(); + + T visitRoleCreation(); + + T visitRoleDeletion(); + + T visitRulesetActivationTitlePreview(); + + T visitRulesetCreation(); + + T visitRulesetDeletion(); + + T visitSearchBrowseEnabledChange(); + + T visitSearchBrowseRequiredChange(); + + T visitSeatChange(); + + T visitSeatRevoke(); + + T visitSecuritySettingsChange(); + + T visitTemporaryExpectationChange(); + + T visitUpfrontEmailCollectionChange(); + + T visitWelcomeMessageChange(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/AdminReplyConversationRequest.java b/src/main/java/com/intercom/api/types/AdminReplyConversationRequest.java index 8c7ee1f..03e39f0 100644 --- a/src/main/java/com/intercom/api/types/AdminReplyConversationRequest.java +++ b/src/main/java/com/intercom/api/types/AdminReplyConversationRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -292,21 +293,79 @@ public AdminReplyConversationRequest build() { } } - public enum MessageType { - COMMENT("comment"), + public static final class MessageType { + public static final MessageType NOTE = new MessageType(Value.NOTE, "note"); - NOTE("note"); + public static final MessageType COMMENT = new MessageType(Value.COMMENT, "comment"); - private final String value; + private final Value value; - MessageType(String value) { + private final String string; + + MessageType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof MessageType && this.string.equals(((MessageType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case NOTE: + return visitor.visitNote(); + case COMMENT: + return visitor.visitComment(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static MessageType valueOf(String value) { + switch (value) { + case "note": + return NOTE; + case "comment": + return COMMENT; + default: + return new MessageType(Value.UNKNOWN, value); + } + } + + public enum Value { + COMMENT, + + NOTE, + + UNKNOWN + } + + public interface Visitor { + T visitComment(); + + T visitNote(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/AdminReplyTicketRequest.java b/src/main/java/com/intercom/api/types/AdminReplyTicketRequest.java index 94bc6a1..dfd118b 100644 --- a/src/main/java/com/intercom/api/types/AdminReplyTicketRequest.java +++ b/src/main/java/com/intercom/api/types/AdminReplyTicketRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -292,23 +293,89 @@ public AdminReplyTicketRequest build() { } } - public enum MessageType { - COMMENT("comment"), + public static final class MessageType { + public static final MessageType NOTE = new MessageType(Value.NOTE, "note"); - NOTE("note"), + public static final MessageType QUICK_REPLY = new MessageType(Value.QUICK_REPLY, "quick_reply"); - QUICK_REPLY("quick_reply"); + public static final MessageType COMMENT = new MessageType(Value.COMMENT, "comment"); - private final String value; + private final Value value; - MessageType(String value) { + private final String string; + + MessageType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) + || (other instanceof MessageType && this.string.equals(((MessageType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case NOTE: + return visitor.visitNote(); + case QUICK_REPLY: + return visitor.visitQuickReply(); + case COMMENT: + return visitor.visitComment(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static MessageType valueOf(String value) { + switch (value) { + case "note": + return NOTE; + case "quick_reply": + return QUICK_REPLY; + case "comment": + return COMMENT; + default: + return new MessageType(Value.UNKNOWN, value); + } + } + + public enum Value { + COMMENT, + + NOTE, + + QUICK_REPLY, + + UNKNOWN + } + + public interface Visitor { + T visitComment(); + + T visitNote(); + + T visitQuickReply(); + + T visitUnknown(String unknownType); } } diff --git a/src/main/java/com/intercom/api/types/ArticleContent.java b/src/main/java/com/intercom/api/types/ArticleContent.java index cd4e52f..62e4ac8 100644 --- a/src/main/java/com/intercom/api/types/ArticleContent.java +++ b/src/main/java/com/intercom/api/types/ArticleContent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -365,21 +366,78 @@ public ArticleContent build() { } } - public enum State { - PUBLISHED("published"), + public static final class State { + public static final State PUBLISHED = new State(Value.PUBLISHED, "published"); - DRAFT("draft"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case PUBLISHED: + return visitor.visitPublished(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "published": + return PUBLISHED; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + PUBLISHED, + + DRAFT, + + UNKNOWN + } + + public interface Visitor { + T visitPublished(); + + T visitDraft(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/AssignConversationRequest.java b/src/main/java/com/intercom/api/types/AssignConversationRequest.java index 0934e8b..ed8cc35 100644 --- a/src/main/java/com/intercom/api/types/AssignConversationRequest.java +++ b/src/main/java/com/intercom/api/types/AssignConversationRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -204,21 +205,78 @@ public AssignConversationRequest build() { } } - public enum Type { - ADMIN("admin"), + public static final class Type { + public static final Type ADMIN = new Type(Value.ADMIN, "admin"); - TEAM("team"); + public static final Type TEAM = new Type(Value.TEAM, "team"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case ADMIN: + return visitor.visitAdmin(); + case TEAM: + return visitor.visitTeam(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "admin": + return ADMIN; + case "team": + return TEAM; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + ADMIN, + + TEAM, + + UNKNOWN + } + + public interface Visitor { + T visitAdmin(); + + T visitTeam(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/ButtonComponent.java b/src/main/java/com/intercom/api/types/ButtonComponent.java index b2c8e25..d17b5a4 100644 --- a/src/main/java/com/intercom/api/types/ButtonComponent.java +++ b/src/main/java/com/intercom/api/types/ButtonComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -248,23 +249,88 @@ public ButtonComponent build() { } } - public enum Style { - PRIMARY("primary"), + public static final class Style { + public static final Style SECONDARY = new Style(Value.SECONDARY, "secondary"); - SECONDARY("secondary"), + public static final Style LINK = new Style(Value.LINK, "link"); - LINK("link"); + public static final Style PRIMARY = new Style(Value.PRIMARY, "primary"); - private final String value; + private final Value value; - Style(String value) { + private final String string; + + Style(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Style && this.string.equals(((Style) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SECONDARY: + return visitor.visitSecondary(); + case LINK: + return visitor.visitLink(); + case PRIMARY: + return visitor.visitPrimary(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Style valueOf(String value) { + switch (value) { + case "secondary": + return SECONDARY; + case "link": + return LINK; + case "primary": + return PRIMARY; + default: + return new Style(Value.UNKNOWN, value); + } + } + + public enum Value { + PRIMARY, + + SECONDARY, + + LINK, + + UNKNOWN + } + + public interface Visitor { + T visitPrimary(); + + T visitSecondary(); + + T visitLink(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/CheckboxComponent.java b/src/main/java/com/intercom/api/types/CheckboxComponent.java index c64873b..7e7d90f 100644 --- a/src/main/java/com/intercom/api/types/CheckboxComponent.java +++ b/src/main/java/com/intercom/api/types/CheckboxComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -306,23 +307,88 @@ public CheckboxComponent build() { } } - public enum SaveState { - UNSAVED("unsaved"), + public static final class SaveState { + public static final SaveState SAVED = new SaveState(Value.SAVED, "saved"); - SAVED("saved"), + public static final SaveState UNSAVED = new SaveState(Value.UNSAVED, "unsaved"); - FAILED("failed"); + public static final SaveState FAILED = new SaveState(Value.FAILED, "failed"); - private final String value; + private final Value value; - SaveState(String value) { + private final String string; + + SaveState(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof SaveState && this.string.equals(((SaveState) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SAVED: + return visitor.visitSaved(); + case UNSAVED: + return visitor.visitUnsaved(); + case FAILED: + return visitor.visitFailed(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static SaveState valueOf(String value) { + switch (value) { + case "saved": + return SAVED; + case "unsaved": + return UNSAVED; + case "failed": + return FAILED; + default: + return new SaveState(Value.UNKNOWN, value); + } + } + + public enum Value { + UNSAVED, + + SAVED, + + FAILED, + + UNKNOWN + } + + public interface Visitor { + T visitUnsaved(); + + T visitSaved(); + + T visitFailed(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/Context.java b/src/main/java/com/intercom/api/types/Context.java index f157693..6919fa1 100644 --- a/src/main/java/com/intercom/api/types/Context.java +++ b/src/main/java/com/intercom/api/types/Context.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -247,25 +248,98 @@ public Context build() { } } - public enum Location { - CONVERSATION("conversation"), + public static final class Location { + public static final Location OPERATOR = new Location(Value.OPERATOR, "operator"); - HOME("home"), + public static final Location MESSAGE = new Location(Value.MESSAGE, "message"); - MESSAGE("message"), + public static final Location HOME = new Location(Value.HOME, "home"); - OPERATOR("operator"); + public static final Location CONVERSATION = new Location(Value.CONVERSATION, "conversation"); - private final String value; + private final Value value; - Location(String value) { + private final String string; + + Location(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Location && this.string.equals(((Location) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case OPERATOR: + return visitor.visitOperator(); + case MESSAGE: + return visitor.visitMessage(); + case HOME: + return visitor.visitHome(); + case CONVERSATION: + return visitor.visitConversation(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Location valueOf(String value) { + switch (value) { + case "operator": + return OPERATOR; + case "message": + return MESSAGE; + case "home": + return HOME; + case "conversation": + return CONVERSATION; + default: + return new Location(Value.UNKNOWN, value); + } + } + + public enum Value { + CONVERSATION, + + HOME, + + MESSAGE, + + OPERATOR, + + UNKNOWN + } + + public interface Visitor { + T visitConversation(); + + T visitHome(); + + T visitMessage(); + + T visitOperator(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/ConversationSource.java b/src/main/java/com/intercom/api/types/ConversationSource.java index 789b224..070cbd0 100644 --- a/src/main/java/com/intercom/api/types/ConversationSource.java +++ b/src/main/java/com/intercom/api/types/ConversationSource.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -383,37 +384,158 @@ public ConversationSource build() { } } - public enum Type { - CONVERSATION("conversation"), + public static final class Type { + public static final Type EMAIL = new Type(Value.EMAIL, "email"); - EMAIL("email"), + public static final Type FACEBOOK = new Type(Value.FACEBOOK, "facebook"); - FACEBOOK("facebook"), + public static final Type INSTAGRAM = new Type(Value.INSTAGRAM, "instagram"); - INSTAGRAM("instagram"), + public static final Type PHONE_CALL = new Type(Value.PHONE_CALL, "phone_call"); - PHONE_CALL("phone_call"), + public static final Type PUSH = new Type(Value.PUSH, "push"); - PHONE_SWITCH("phone_switch"), + public static final Type WHATSAPP = new Type(Value.WHATSAPP, "whatsapp"); - PUSH("push"), + public static final Type SMS = new Type(Value.SMS, "sms"); - SMS("sms"), + public static final Type CONVERSATION = new Type(Value.CONVERSATION, "conversation"); - TWITTER("twitter"), + public static final Type TWITTER = new Type(Value.TWITTER, "twitter"); - WHATSAPP("whatsapp"); + public static final Type PHONE_SWITCH = new Type(Value.PHONE_SWITCH, "phone_switch"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case EMAIL: + return visitor.visitEmail(); + case FACEBOOK: + return visitor.visitFacebook(); + case INSTAGRAM: + return visitor.visitInstagram(); + case PHONE_CALL: + return visitor.visitPhoneCall(); + case PUSH: + return visitor.visitPush(); + case WHATSAPP: + return visitor.visitWhatsapp(); + case SMS: + return visitor.visitSms(); + case CONVERSATION: + return visitor.visitConversation(); + case TWITTER: + return visitor.visitTwitter(); + case PHONE_SWITCH: + return visitor.visitPhoneSwitch(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "email": + return EMAIL; + case "facebook": + return FACEBOOK; + case "instagram": + return INSTAGRAM; + case "phone_call": + return PHONE_CALL; + case "push": + return PUSH; + case "whatsapp": + return WHATSAPP; + case "sms": + return SMS; + case "conversation": + return CONVERSATION; + case "twitter": + return TWITTER; + case "phone_switch": + return PHONE_SWITCH; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + CONVERSATION, + + EMAIL, + + FACEBOOK, + + INSTAGRAM, + + PHONE_CALL, + + PHONE_SWITCH, + + PUSH, + + SMS, + + TWITTER, + + WHATSAPP, + + UNKNOWN + } + + public interface Visitor { + T visitConversation(); + + T visitEmail(); + + T visitFacebook(); + + T visitInstagram(); + + T visitPhoneCall(); + + T visitPhoneSwitch(); + + T visitPush(); + + T visitSms(); + + T visitTwitter(); + + T visitWhatsapp(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/CreateMessageRequest.java b/src/main/java/com/intercom/api/types/CreateMessageRequest.java index 3b455b1..c5d5115 100644 --- a/src/main/java/com/intercom/api/types/CreateMessageRequest.java +++ b/src/main/java/com/intercom/api/types/CreateMessageRequest.java @@ -743,21 +743,78 @@ public To build() { } } - public enum Type { - USER("user"), + public static final class Type { + public static final Type USER = new Type(Value.USER, "user"); - LEAD("lead"); + public static final Type LEAD = new Type(Value.LEAD, "lead"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case USER: + return visitor.visitUser(); + case LEAD: + return visitor.visitLead(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "user": + return USER; + case "lead": + return LEAD; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + USER, + + LEAD, + + UNKNOWN + } + + public interface Visitor { + T visitUser(); + + T visitLead(); + + T visitUnknown(String unknownType); } } } @@ -1302,21 +1359,78 @@ public To build() { } } - public enum Type { - USER("user"), + public static final class Type { + public static final Type USER = new Type(Value.USER, "user"); - LEAD("lead"); + public static final Type LEAD = new Type(Value.LEAD, "lead"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case USER: + return visitor.visitUser(); + case LEAD: + return visitor.visitLead(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "user": + return USER; + case "lead": + return LEAD; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + USER, + + LEAD, + + UNKNOWN + } + + public interface Visitor { + T visitUser(); + + T visitLead(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/DropdownComponent.java b/src/main/java/com/intercom/api/types/DropdownComponent.java index 5dd68e9..5ea240f 100644 --- a/src/main/java/com/intercom/api/types/DropdownComponent.java +++ b/src/main/java/com/intercom/api/types/DropdownComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -312,23 +313,88 @@ public DropdownComponent build() { } } - public enum SaveState { - UNSAVED("unsaved"), + public static final class SaveState { + public static final SaveState SAVED = new SaveState(Value.SAVED, "saved"); - SAVED("saved"), + public static final SaveState UNSAVED = new SaveState(Value.UNSAVED, "unsaved"); - FAILED("failed"); + public static final SaveState FAILED = new SaveState(Value.FAILED, "failed"); - private final String value; + private final Value value; - SaveState(String value) { + private final String string; + + SaveState(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof SaveState && this.string.equals(((SaveState) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SAVED: + return visitor.visitSaved(); + case UNSAVED: + return visitor.visitUnsaved(); + case FAILED: + return visitor.visitFailed(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static SaveState valueOf(String value) { + switch (value) { + case "saved": + return SAVED; + case "unsaved": + return UNSAVED; + case "failed": + return FAILED; + default: + return new SaveState(Value.UNKNOWN, value); + } + } + + public enum Value { + UNSAVED, + + SAVED, + + FAILED, + + UNKNOWN + } + + public interface Visitor { + T visitUnsaved(); + + T visitSaved(); + + T visitFailed(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/ImageComponent.java b/src/main/java/com/intercom/api/types/ImageComponent.java index 7e791af..4738013 100644 --- a/src/main/java/com/intercom/api/types/ImageComponent.java +++ b/src/main/java/com/intercom/api/types/ImageComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -361,25 +362,98 @@ public ImageComponent build() { } } - public enum Align { - LEFT("left"), + public static final class Align { + public static final Align LEFT = new Align(Value.LEFT, "left"); - CENTER("center"), + public static final Align RIGHT = new Align(Value.RIGHT, "right"); - RIGHT("right"), + public static final Align CENTER = new Align(Value.CENTER, "center"); - FULL_WIDTH("full_width"); + public static final Align FULL_WIDTH = new Align(Value.FULL_WIDTH, "full_width"); - private final String value; + private final Value value; - Align(String value) { + private final String string; + + Align(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Align && this.string.equals(((Align) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case LEFT: + return visitor.visitLeft(); + case RIGHT: + return visitor.visitRight(); + case CENTER: + return visitor.visitCenter(); + case FULL_WIDTH: + return visitor.visitFullWidth(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Align valueOf(String value) { + switch (value) { + case "left": + return LEFT; + case "right": + return RIGHT; + case "center": + return CENTER; + case "full_width": + return FULL_WIDTH; + default: + return new Align(Value.UNKNOWN, value); + } + } + + public enum Value { + LEFT, + + CENTER, + + RIGHT, + + FULL_WIDTH, + + UNKNOWN + } + + public interface Visitor { + T visitLeft(); + + T visitCenter(); + + T visitRight(); + + T visitFullWidth(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/InputComponent.java b/src/main/java/com/intercom/api/types/InputComponent.java index 6109ce6..e2a0498 100644 --- a/src/main/java/com/intercom/api/types/InputComponent.java +++ b/src/main/java/com/intercom/api/types/InputComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -335,23 +336,88 @@ public InputComponent build() { } } - public enum SaveState { - UNSAVED("unsaved"), + public static final class SaveState { + public static final SaveState SAVED = new SaveState(Value.SAVED, "saved"); - SAVED("saved"), + public static final SaveState UNSAVED = new SaveState(Value.UNSAVED, "unsaved"); - FAILED("failed"); + public static final SaveState FAILED = new SaveState(Value.FAILED, "failed"); - private final String value; + private final Value value; - SaveState(String value) { + private final String string; + + SaveState(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof SaveState && this.string.equals(((SaveState) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SAVED: + return visitor.visitSaved(); + case UNSAVED: + return visitor.visitUnsaved(); + case FAILED: + return visitor.visitFailed(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static SaveState valueOf(String value) { + switch (value) { + case "saved": + return SAVED; + case "unsaved": + return UNSAVED; + case "failed": + return FAILED; + default: + return new SaveState(Value.UNKNOWN, value); + } + } + + public enum Value { + UNSAVED, + + SAVED, + + FAILED, + + UNKNOWN + } + + public interface Visitor { + T visitUnsaved(); + + T visitSaved(); + + T visitFailed(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/LinkedObject.java b/src/main/java/com/intercom/api/types/LinkedObject.java index 21c775a..e4ac8ba 100644 --- a/src/main/java/com/intercom/api/types/LinkedObject.java +++ b/src/main/java/com/intercom/api/types/LinkedObject.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -174,21 +175,78 @@ public LinkedObject build() { } } - public enum Type { - TICKET("ticket"), + public static final class Type { + public static final Type TICKET = new Type(Value.TICKET, "ticket"); - CONVERSATION("conversation"); + public static final Type CONVERSATION = new Type(Value.CONVERSATION, "conversation"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case TICKET: + return visitor.visitTicket(); + case CONVERSATION: + return visitor.visitConversation(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "ticket": + return TICKET; + case "conversation": + return CONVERSATION; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + TICKET, + + CONVERSATION, + + UNKNOWN + } + + public interface Visitor { + T visitTicket(); + + T visitConversation(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/MultipleFilterSearchRequest.java b/src/main/java/com/intercom/api/types/MultipleFilterSearchRequest.java index 6bb8bd5..8a6fde2 100644 --- a/src/main/java/com/intercom/api/types/MultipleFilterSearchRequest.java +++ b/src/main/java/com/intercom/api/types/MultipleFilterSearchRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -123,21 +124,78 @@ public MultipleFilterSearchRequest build() { } } - public enum Operator { - AND("AND"), + public static final class Operator { + public static final Operator AND = new Operator(Value.AND, "AND"); - OR("OR"); + public static final Operator OR = new Operator(Value.OR, "OR"); - private final String value; + private final Value value; - Operator(String value) { + private final String string; + + Operator(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Operator && this.string.equals(((Operator) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case AND: + return visitor.visitAnd(); + case OR: + return visitor.visitOr(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Operator valueOf(String value) { + switch (value) { + case "AND": + return AND; + case "OR": + return OR; + default: + return new Operator(Value.UNKNOWN, value); + } + } + + public enum Value { + AND, + + OR, + + UNKNOWN + } + + public interface Visitor { + T visitAnd(); + + T visitOr(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/NewsItemRequest.java b/src/main/java/com/intercom/api/types/NewsItemRequest.java index 21e71c2..18ae93a 100644 --- a/src/main/java/com/intercom/api/types/NewsItemRequest.java +++ b/src/main/java/com/intercom/api/types/NewsItemRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -384,21 +385,78 @@ public NewsItemRequest build() { } } - public enum State { - DRAFT("draft"), + public static final class State { + public static final State LIVE = new State(Value.LIVE, "live"); - LIVE("live"); + public static final State DRAFT = new State(Value.DRAFT, "draft"); - private final String value; + private final Value value; - State(String value) { + private final String string; + + State(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof State && this.string.equals(((State) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case LIVE: + return visitor.visitLive(); + case DRAFT: + return visitor.visitDraft(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static State valueOf(String value) { + switch (value) { + case "live": + return LIVE; + case "draft": + return DRAFT; + default: + return new State(Value.UNKNOWN, value); + } + } + + public enum Value { + DRAFT, + + LIVE, + + UNKNOWN + } + + public interface Visitor { + T visitDraft(); + + T visitLive(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/SingleFilterSearchRequest.java b/src/main/java/com/intercom/api/types/SingleFilterSearchRequest.java index e05627b..4bc4e1d 100644 --- a/src/main/java/com/intercom/api/types/SingleFilterSearchRequest.java +++ b/src/main/java/com/intercom/api/types/SingleFilterSearchRequest.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -158,37 +159,158 @@ public SingleFilterSearchRequest build() { } } - public enum Operator { - EQUALS("="), + public static final class Operator { + public static final Operator GREATER_THAN = new Operator(Value.GREATER_THAN, ">"); - NOT_EQUALS("!="), + public static final Operator DOES_NOT_CONTAIN = new Operator(Value.DOES_NOT_CONTAIN, "!~"); - IN("IN"), + public static final Operator IN = new Operator(Value.IN, "IN"); - NOT_IN("NIN"), + public static final Operator CONTAINS = new Operator(Value.CONTAINS, "~"); - LESS_THAN("<"), + public static final Operator LESS_THAN = new Operator(Value.LESS_THAN, "<"); - GREATER_THAN(">"), + public static final Operator EQUALS = new Operator(Value.EQUALS, "="); - CONTAINS("~"), + public static final Operator NOT_EQUALS = new Operator(Value.NOT_EQUALS, "!="); - DOES_NOT_CONTAIN("!~"), + public static final Operator ENDS_WITH = new Operator(Value.ENDS_WITH, "$"); - STARTS_WITH("^"), + public static final Operator STARTS_WITH = new Operator(Value.STARTS_WITH, "^"); - ENDS_WITH("$"); + public static final Operator NOT_IN = new Operator(Value.NOT_IN, "NIN"); - private final String value; + private final Value value; - Operator(String value) { + private final String string; + + Operator(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Operator && this.string.equals(((Operator) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case GREATER_THAN: + return visitor.visitGreaterThan(); + case DOES_NOT_CONTAIN: + return visitor.visitDoesNotContain(); + case IN: + return visitor.visitIn(); + case CONTAINS: + return visitor.visitContains(); + case LESS_THAN: + return visitor.visitLessThan(); + case EQUALS: + return visitor.visitEquals(); + case NOT_EQUALS: + return visitor.visitNotEquals(); + case ENDS_WITH: + return visitor.visitEndsWith(); + case STARTS_WITH: + return visitor.visitStartsWith(); + case NOT_IN: + return visitor.visitNotIn(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Operator valueOf(String value) { + switch (value) { + case ">": + return GREATER_THAN; + case "!~": + return DOES_NOT_CONTAIN; + case "IN": + return IN; + case "~": + return CONTAINS; + case "<": + return LESS_THAN; + case "=": + return EQUALS; + case "!=": + return NOT_EQUALS; + case "$": + return ENDS_WITH; + case "^": + return STARTS_WITH; + case "NIN": + return NOT_IN; + default: + return new Operator(Value.UNKNOWN, value); + } + } + + public enum Value { + EQUALS, + + NOT_EQUALS, + + IN, + + NOT_IN, + + LESS_THAN, + + GREATER_THAN, + + CONTAINS, + + DOES_NOT_CONTAIN, + + STARTS_WITH, + + ENDS_WITH, + + UNKNOWN + } + + public interface Visitor { + T visitEquals(); + + T visitNotEquals(); + + T visitIn(); + + T visitNotIn(); + + T visitLessThan(); + + T visitGreaterThan(); + + T visitContains(); + + T visitDoesNotContain(); + + T visitStartsWith(); + + T visitEndsWith(); + + T visitUnknown(String unknownType); } } diff --git a/src/main/java/com/intercom/api/types/SingleSelectComponent.java b/src/main/java/com/intercom/api/types/SingleSelectComponent.java index 9f4e752..4feec78 100644 --- a/src/main/java/com/intercom/api/types/SingleSelectComponent.java +++ b/src/main/java/com/intercom/api/types/SingleSelectComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -350,23 +351,88 @@ public SingleSelectComponent build() { } } - public enum SaveState { - UNSAVED("unsaved"), + public static final class SaveState { + public static final SaveState SAVED = new SaveState(Value.SAVED, "saved"); - SAVED("saved"), + public static final SaveState UNSAVED = new SaveState(Value.UNSAVED, "unsaved"); - FAILED("failed"); + public static final SaveState FAILED = new SaveState(Value.FAILED, "failed"); - private final String value; + private final Value value; - SaveState(String value) { + private final String string; + + SaveState(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof SaveState && this.string.equals(((SaveState) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case SAVED: + return visitor.visitSaved(); + case UNSAVED: + return visitor.visitUnsaved(); + case FAILED: + return visitor.visitFailed(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static SaveState valueOf(String value) { + switch (value) { + case "saved": + return SAVED; + case "unsaved": + return UNSAVED; + case "failed": + return FAILED; + default: + return new SaveState(Value.UNKNOWN, value); + } + } + + public enum Value { + UNSAVED, + + SAVED, + + FAILED, + + UNKNOWN + } + + public interface Visitor { + T visitUnsaved(); + + T visitSaved(); + + T visitFailed(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/SlaApplied.java b/src/main/java/com/intercom/api/types/SlaApplied.java index f102a04..8f2910b 100644 --- a/src/main/java/com/intercom/api/types/SlaApplied.java +++ b/src/main/java/com/intercom/api/types/SlaApplied.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -172,25 +173,98 @@ public SlaApplied build() { } } - public enum SlaStatus { - HIT("hit"), + public static final class SlaStatus { + public static final SlaStatus HIT = new SlaStatus(Value.HIT, "hit"); - MISSED("missed"), + public static final SlaStatus CANCELLED = new SlaStatus(Value.CANCELLED, "cancelled"); - CANCELLED("cancelled"), + public static final SlaStatus ACTIVE = new SlaStatus(Value.ACTIVE, "active"); - ACTIVE("active"); + public static final SlaStatus MISSED = new SlaStatus(Value.MISSED, "missed"); - private final String value; + private final Value value; - SlaStatus(String value) { + private final String string; + + SlaStatus(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof SlaStatus && this.string.equals(((SlaStatus) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case HIT: + return visitor.visitHit(); + case CANCELLED: + return visitor.visitCancelled(); + case ACTIVE: + return visitor.visitActive(); + case MISSED: + return visitor.visitMissed(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static SlaStatus valueOf(String value) { + switch (value) { + case "hit": + return HIT; + case "cancelled": + return CANCELLED; + case "active": + return ACTIVE; + case "missed": + return MISSED; + default: + return new SlaStatus(Value.UNKNOWN, value); + } + } + + public enum Value { + HIT, + + MISSED, + + CANCELLED, + + ACTIVE, + + UNKNOWN + } + + public interface Visitor { + T visitHit(); + + T visitMissed(); + + T visitCancelled(); + + T visitActive(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/SpacerComponent.java b/src/main/java/com/intercom/api/types/SpacerComponent.java index 66c1a99..76b5616 100644 --- a/src/main/java/com/intercom/api/types/SpacerComponent.java +++ b/src/main/java/com/intercom/api/types/SpacerComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -122,27 +123,108 @@ public SpacerComponent build() { } } - public enum Size { - XS("xs"), + public static final class Size { + public static final Size XS = new Size(Value.XS, "xs"); - S("s"), + public static final Size S = new Size(Value.S, "s"); - M("m"), + public static final Size L = new Size(Value.L, "l"); - L("l"), + public static final Size XL = new Size(Value.XL, "xl"); - XL("xl"); + public static final Size M = new Size(Value.M, "m"); - private final String value; + private final Value value; - Size(String value) { + private final String string; + + Size(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Size && this.string.equals(((Size) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case XS: + return visitor.visitXs(); + case S: + return visitor.visitS(); + case L: + return visitor.visitL(); + case XL: + return visitor.visitXl(); + case M: + return visitor.visitM(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Size valueOf(String value) { + switch (value) { + case "xs": + return XS; + case "s": + return S; + case "l": + return L; + case "xl": + return XL; + case "m": + return M; + default: + return new Size(Value.UNKNOWN, value); + } + } + + public enum Value { + XS, + + S, + + M, + + L, + + XL, + + UNKNOWN + } + + public interface Visitor { + T visitXs(); + + T visitS(); + + T visitM(); + + T visitL(); + + T visitXl(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/TextComponent.java b/src/main/java/com/intercom/api/types/TextComponent.java index f68f314..9f57ee5 100644 --- a/src/main/java/com/intercom/api/types/TextComponent.java +++ b/src/main/java/com/intercom/api/types/TextComponent.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -260,45 +261,183 @@ public TextComponent build() { } } - public enum Style { - HEADER("header"), + public static final class Style { + public static final Style MUTED = new Style(Value.MUTED, "muted"); - PARAGRAPH("paragraph"), + public static final Style HEADER = new Style(Value.HEADER, "header"); - MUTED("muted"), + public static final Style PARAGRAPH = new Style(Value.PARAGRAPH, "paragraph"); - ERROR("error"); + public static final Style ERROR = new Style(Value.ERROR, "error"); - private final String value; + private final Value value; - Style(String value) { + private final String string; + + Style(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Style && this.string.equals(((Style) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case MUTED: + return visitor.visitMuted(); + case HEADER: + return visitor.visitHeader(); + case PARAGRAPH: + return visitor.visitParagraph(); + case ERROR: + return visitor.visitError(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Style valueOf(String value) { + switch (value) { + case "muted": + return MUTED; + case "header": + return HEADER; + case "paragraph": + return PARAGRAPH; + case "error": + return ERROR; + default: + return new Style(Value.UNKNOWN, value); + } + } + + public enum Value { + HEADER, + + PARAGRAPH, + + MUTED, + + ERROR, + + UNKNOWN + } + + public interface Visitor { + T visitHeader(); + + T visitParagraph(); + + T visitMuted(); + + T visitError(); + + T visitUnknown(String unknownType); } } - public enum Align { - LEFT("left"), + public static final class Align { + public static final Align LEFT = new Align(Value.LEFT, "left"); + + public static final Align RIGHT = new Align(Value.RIGHT, "right"); - CENTER("center"), + public static final Align CENTER = new Align(Value.CENTER, "center"); - RIGHT("right"); + private final Value value; - private final String value; + private final String string; - Align(String value) { + Align(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Align && this.string.equals(((Align) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case LEFT: + return visitor.visitLeft(); + case RIGHT: + return visitor.visitRight(); + case CENTER: + return visitor.visitCenter(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Align valueOf(String value) { + switch (value) { + case "left": + return LEFT; + case "right": + return RIGHT; + case "center": + return CENTER; + default: + return new Align(Value.UNKNOWN, value); + } + } + + public enum Value { + LEFT, + + CENTER, + + RIGHT, + + UNKNOWN + } + + public interface Visitor { + T visitLeft(); + + T visitCenter(); + + T visitRight(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/TicketPartAuthor.java b/src/main/java/com/intercom/api/types/TicketPartAuthor.java index 08626fe..f08cae3 100644 --- a/src/main/java/com/intercom/api/types/TicketPartAuthor.java +++ b/src/main/java/com/intercom/api/types/TicketPartAuthor.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -204,25 +205,98 @@ public TicketPartAuthor build() { } } - public enum Type { - ADMIN("admin"), + public static final class Type { + public static final Type BOT = new Type(Value.BOT, "bot"); - BOT("bot"), + public static final Type ADMIN = new Type(Value.ADMIN, "admin"); - TEAM("team"), + public static final Type USER = new Type(Value.USER, "user"); - USER("user"); + public static final Type TEAM = new Type(Value.TEAM, "team"); - private final String value; + private final Value value; - Type(String value) { + private final String string; + + Type(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof Type && this.string.equals(((Type) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case BOT: + return visitor.visitBot(); + case ADMIN: + return visitor.visitAdmin(); + case USER: + return visitor.visitUser(); + case TEAM: + return visitor.visitTeam(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static Type valueOf(String value) { + switch (value) { + case "bot": + return BOT; + case "admin": + return ADMIN; + case "user": + return USER; + case "team": + return TEAM; + default: + return new Type(Value.UNKNOWN, value); + } + } + + public enum Value { + ADMIN, + + BOT, + + TEAM, + + USER, + + UNKNOWN + } + + public interface Visitor { + T visitAdmin(); + + T visitBot(); + + T visitTeam(); + + T visitUser(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/TicketReply.java b/src/main/java/com/intercom/api/types/TicketReply.java index c3c6c33..c2e6e67 100644 --- a/src/main/java/com/intercom/api/types/TicketReply.java +++ b/src/main/java/com/intercom/api/types/TicketReply.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -370,23 +371,88 @@ public TicketReply build() { } } - public enum PartType { - NOTE("note"), + public static final class PartType { + public static final PartType NOTE = new PartType(Value.NOTE, "note"); - COMMENT("comment"), + public static final PartType QUICK_REPLY = new PartType(Value.QUICK_REPLY, "quick_reply"); - QUICK_REPLY("quick_reply"); + public static final PartType COMMENT = new PartType(Value.COMMENT, "comment"); - private final String value; + private final Value value; - PartType(String value) { + private final String string; + + PartType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof PartType && this.string.equals(((PartType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case NOTE: + return visitor.visitNote(); + case QUICK_REPLY: + return visitor.visitQuickReply(); + case COMMENT: + return visitor.visitComment(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static PartType valueOf(String value) { + switch (value) { + case "note": + return NOTE; + case "quick_reply": + return QUICK_REPLY; + case "comment": + return COMMENT; + default: + return new PartType(Value.UNKNOWN, value); + } + } + + public enum Value { + NOTE, + + COMMENT, + + QUICK_REPLY, + + UNKNOWN + } + + public interface Visitor { + T visitNote(); + + T visitComment(); + + T visitQuickReply(); + + T visitUnknown(String unknownType); } } } diff --git a/src/main/java/com/intercom/api/types/TicketTypeAttribute.java b/src/main/java/com/intercom/api/types/TicketTypeAttribute.java index 364952a..773351a 100644 --- a/src/main/java/com/intercom/api/types/TicketTypeAttribute.java +++ b/src/main/java/com/intercom/api/types/TicketTypeAttribute.java @@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonProperty; @@ -659,31 +660,128 @@ public TicketTypeAttribute build() { } } - public enum DataType { - STRING("string"), + public static final class DataType { + public static final DataType STRING = new DataType(Value.STRING, "string"); - LIST("list"), + public static final DataType DECIMAL = new DataType(Value.DECIMAL, "decimal"); - INTEGER("integer"), + public static final DataType LIST = new DataType(Value.LIST, "list"); - DECIMAL("decimal"), + public static final DataType INTEGER = new DataType(Value.INTEGER, "integer"); - BOOLEAN("boolean"), + public static final DataType DATETIME = new DataType(Value.DATETIME, "datetime"); - DATETIME("datetime"), + public static final DataType BOOLEAN = new DataType(Value.BOOLEAN, "boolean"); - FILES("files"); + public static final DataType FILES = new DataType(Value.FILES, "files"); - private final String value; + private final Value value; - DataType(String value) { + private final String string; + + DataType(Value value, String string) { this.value = value; + this.string = string; + } + + public Value getEnumValue() { + return value; } - @JsonValue @java.lang.Override + @JsonValue public String toString() { - return this.value; + return this.string; + } + + @java.lang.Override + public boolean equals(Object other) { + return (this == other) || (other instanceof DataType && this.string.equals(((DataType) other).string)); + } + + @java.lang.Override + public int hashCode() { + return this.string.hashCode(); + } + + public T visit(Visitor visitor) { + switch (value) { + case STRING: + return visitor.visitString(); + case DECIMAL: + return visitor.visitDecimal(); + case LIST: + return visitor.visitList(); + case INTEGER: + return visitor.visitInteger(); + case DATETIME: + return visitor.visitDatetime(); + case BOOLEAN: + return visitor.visitBoolean(); + case FILES: + return visitor.visitFiles(); + case UNKNOWN: + default: + return visitor.visitUnknown(string); + } + } + + @JsonCreator(mode = JsonCreator.Mode.DELEGATING) + public static DataType valueOf(String value) { + switch (value) { + case "string": + return STRING; + case "decimal": + return DECIMAL; + case "list": + return LIST; + case "integer": + return INTEGER; + case "datetime": + return DATETIME; + case "boolean": + return BOOLEAN; + case "files": + return FILES; + default: + return new DataType(Value.UNKNOWN, value); + } + } + + public enum Value { + STRING, + + LIST, + + INTEGER, + + DECIMAL, + + BOOLEAN, + + DATETIME, + + FILES, + + UNKNOWN + } + + public interface Visitor { + T visitString(); + + T visitList(); + + T visitInteger(); + + T visitDecimal(); + + T visitBoolean(); + + T visitDatetime(); + + T visitFiles(); + + T visitUnknown(String unknownType); } } }