org.openmetadata.client.api.GlossariesApi Maven / Gradle / Ivy
package org.openmetadata.client.api;
import org.openmetadata.client.ApiClient;
import org.openmetadata.client.EncodingUtils;
import org.openmetadata.client.model.ApiResponse;
import org.openmetadata.client.model.AddGlossaryToAssetsRequest;
import org.openmetadata.client.model.BulkOperationResult;
import org.openmetadata.client.model.ChangeEvent;
import org.openmetadata.client.model.CreateGlossary;
import org.openmetadata.client.model.CreateGlossaryTerm;
import org.openmetadata.client.model.CsvImportResult;
import org.openmetadata.client.model.EntityHistory;
import org.openmetadata.client.model.Glossary;
import org.openmetadata.client.model.GlossaryList;
import org.openmetadata.client.model.GlossaryTerm;
import org.openmetadata.client.model.GlossaryTermList;
import org.openmetadata.client.model.RestoreEntity;
import java.util.UUID;
import org.openmetadata.client.model.VoteRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import feign.*;
@javax.annotation.Generated(value = "org.openapitools.codegen.languages.JavaClientCodegen", date = "2024-07-25T09:42:14.348793228Z[Etc/UTC]")
public interface GlossariesApi extends ApiClient.Api {
/**
* Bulk Add Glossary Term to Assets
* Bulk Add Glossary Term to Assets
* @param id Id of the Entity (required)
* @param addGlossaryToAssetsRequest (optional)
* @return BulkOperationResult
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/assets/add")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
BulkOperationResult bulkAddGlossaryTermToAssets(@Param("id") UUID id, AddGlossaryToAssetsRequest addGlossaryToAssetsRequest);
/**
* Bulk Add Glossary Term to Assets
* Similar to bulkAddGlossaryTermToAssets but it also returns the http response headers .
* Bulk Add Glossary Term to Assets
* @param id Id of the Entity (required)
* @param addGlossaryToAssetsRequest (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/assets/add")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse bulkAddGlossaryTermToAssetsWithHttpInfo(@Param("id") UUID id, AddGlossaryToAssetsRequest addGlossaryToAssetsRequest);
/**
* Bulk Remove Glossary Term from Assets
* Bulk Remove Glossary Term from Assets
* @param id Id of the Entity (required)
* @param addGlossaryToAssetsRequest (optional)
* @return ChangeEvent
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/assets/remove")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ChangeEvent bulkRemoveGlossaryTermFromAssets(@Param("id") UUID id, AddGlossaryToAssetsRequest addGlossaryToAssetsRequest);
/**
* Bulk Remove Glossary Term from Assets
* Similar to bulkRemoveGlossaryTermFromAssets but it also returns the http response headers .
* Bulk Remove Glossary Term from Assets
* @param id Id of the Entity (required)
* @param addGlossaryToAssetsRequest (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/assets/remove")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse bulkRemoveGlossaryTermFromAssetsWithHttpInfo(@Param("id") UUID id, AddGlossaryToAssetsRequest addGlossaryToAssetsRequest);
/**
* Create a glossary
* Create a new glossary.
* @param createGlossary (optional)
* @return Glossary
*/
@RequestLine("POST /v1/glossaries")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
Glossary createGlossary(CreateGlossary createGlossary);
/**
* Create a glossary
* Similar to createGlossary but it also returns the http response headers .
* Create a new glossary.
* @param createGlossary (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("POST /v1/glossaries")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createGlossaryWithHttpInfo(CreateGlossary createGlossary);
/**
* Create a glossary term
* Create a new glossary term.
* @param createGlossaryTerm (optional)
* @return GlossaryTerm
*/
@RequestLine("POST /v1/glossaryTerms")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
GlossaryTerm createGlossaryTerm(CreateGlossaryTerm createGlossaryTerm);
/**
* Create a glossary term
* Similar to createGlossaryTerm but it also returns the http response headers .
* Create a new glossary term.
* @param createGlossaryTerm (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("POST /v1/glossaryTerms")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createGlossaryTermWithHttpInfo(CreateGlossaryTerm createGlossaryTerm);
/**
* Create or update a glossary
* Create a new glossary, if it does not exist or update an existing glossary.
* @param createGlossary (optional)
* @return Glossary
*/
@RequestLine("PUT /v1/glossaries")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
Glossary createOrUpdateGlossary(CreateGlossary createGlossary);
/**
* Create or update a glossary
* Similar to createOrUpdateGlossary but it also returns the http response headers .
* Create a new glossary, if it does not exist or update an existing glossary.
* @param createGlossary (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaries")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createOrUpdateGlossaryWithHttpInfo(CreateGlossary createGlossary);
/**
* Create or update a glossary term
* Create a new glossary term, if it does not exist or update an existing glossary term.
* @param createGlossaryTerm (optional)
* @return GlossaryTerm
*/
@RequestLine("PUT /v1/glossaryTerms")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
GlossaryTerm createOrUpdateGlossaryTerm(CreateGlossaryTerm createGlossaryTerm);
/**
* Create or update a glossary term
* Similar to createOrUpdateGlossaryTerm but it also returns the http response headers .
* Create a new glossary term, if it does not exist or update an existing glossary term.
* @param createGlossaryTerm (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaryTerms")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createOrUpdateGlossaryTermWithHttpInfo(CreateGlossaryTerm createGlossaryTerm);
/**
* Delete a glossary term by Id
* Delete a glossary term by `Id`.
* @param id Id of the glossary term (required)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaryTerms/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void delete(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a glossary term by Id
* Similar to delete but it also returns the http response headers .
* Delete a glossary term by `Id`.
* @param id Id of the glossary term (required)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaryTerms/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteWithHttpInfo(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a glossary term by Id
* Delete a glossary term by `Id`.
* Note, this is equivalent to the other delete method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link DeleteQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaryTerms/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void delete(@Param("id") UUID id, @QueryMap(encoded=true) DeleteQueryParams queryParams);
/**
* Delete a glossary term by Id
* Delete a glossary term by `Id`.
* Note, this is equivalent to the other delete that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaryTerms/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) DeleteQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* delete method in a fluent style.
*/
public static class DeleteQueryParams extends HashMap {
public DeleteQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
public DeleteQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
}
/**
* Delete a glossary by Id
* Delete a glossary by `Id`.
* @param id Id of the glossary (required)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaries/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteGlossary(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a glossary by Id
* Similar to deleteGlossary but it also returns the http response headers .
* Delete a glossary by `Id`.
* @param id Id of the glossary (required)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaries/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteGlossaryWithHttpInfo(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a glossary by Id
* Delete a glossary by `Id`.
* Note, this is equivalent to the other deleteGlossary method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link DeleteGlossaryQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaries/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteGlossary(@Param("id") UUID id, @QueryMap(encoded=true) DeleteGlossaryQueryParams queryParams);
/**
* Delete a glossary by Id
* Delete a glossary by `Id`.
* Note, this is equivalent to the other deleteGlossary that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaries/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteGlossaryWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) DeleteGlossaryQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteGlossary method in a fluent style.
*/
public static class DeleteGlossaryQueryParams extends HashMap {
public DeleteGlossaryQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
public DeleteGlossaryQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
}
/**
* Delete a glossary by name
* Delete a glossary by `name`.
* @param name Name of the glossary (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaries/name/{name}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteGlossaryByName(@Param("name") String name, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a glossary by name
* Similar to deleteGlossaryByName but it also returns the http response headers .
* Delete a glossary by `name`.
* @param name Name of the glossary (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaries/name/{name}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteGlossaryByNameWithHttpInfo(@Param("name") String name, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a glossary by name
* Delete a glossary by `name`.
* Note, this is equivalent to the other deleteGlossaryByName method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link DeleteGlossaryByNameQueryParams} class that allows for
* building up this map in a fluent style.
* @param name Name of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaries/name/{name}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteGlossaryByName(@Param("name") String name, @QueryMap(encoded=true) DeleteGlossaryByNameQueryParams queryParams);
/**
* Delete a glossary by name
* Delete a glossary by `name`.
* Note, this is equivalent to the other deleteGlossaryByName that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param name Name of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaries/name/{name}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteGlossaryByNameWithHttpInfo(@Param("name") String name, @QueryMap(encoded=true) DeleteGlossaryByNameQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteGlossaryByName method in a fluent style.
*/
public static class DeleteGlossaryByNameQueryParams extends HashMap {
public DeleteGlossaryByNameQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
public DeleteGlossaryByNameQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
}
/**
* Delete a glossary term by fully qualified name
* Delete a glossary term by `fullyQualifiedName`.
* @param fqn Fully qualified name of the glossary term (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaryTerms/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteGlossaryTermByName(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a glossary term by fully qualified name
* Similar to deleteGlossaryTermByName but it also returns the http response headers .
* Delete a glossary term by `fullyQualifiedName`.
* @param fqn Fully qualified name of the glossary term (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/glossaryTerms/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteGlossaryTermByNameWithHttpInfo(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a glossary term by fully qualified name
* Delete a glossary term by `fullyQualifiedName`.
* Note, this is equivalent to the other deleteGlossaryTermByName method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link DeleteGlossaryTermByNameQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Fully qualified name of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaryTerms/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteGlossaryTermByName(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteGlossaryTermByNameQueryParams queryParams);
/**
* Delete a glossary term by fully qualified name
* Delete a glossary term by `fullyQualifiedName`.
* Note, this is equivalent to the other deleteGlossaryTermByName that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Fully qualified name of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/glossaryTerms/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteGlossaryTermByNameWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteGlossaryTermByNameQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteGlossaryTermByName method in a fluent style.
*/
public static class DeleteGlossaryTermByNameQueryParams extends HashMap {
public DeleteGlossaryTermByNameQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
public DeleteGlossaryTermByNameQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
}
/**
* Export glossary in CSV format
*
* @param name Name of the glossary (required)
* @return String
*/
@RequestLine("GET /v1/glossaries/name/{name}/export")
@Headers({
"Accept: application/json",
})
String exportGlossary(@Param("name") String name);
/**
* Export glossary in CSV format
* Similar to exportGlossary but it also returns the http response headers .
*
* @param name Name of the glossary (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaries/name/{name}/export")
@Headers({
"Accept: application/json",
})
ApiResponse exportGlossaryWithHttpInfo(@Param("name") String name);
/**
* Get CSV documentation
*
* @param name Name of the glossary (required)
* @return String
*/
@RequestLine("GET /v1/glossaries/documentation/csv")
@Headers({
"Accept: application/json",
})
String getCsvDocumentation(@Param("name") String name);
/**
* Get CSV documentation
* Similar to getCsvDocumentation but it also returns the http response headers .
*
* @param name Name of the glossary (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaries/documentation/csv")
@Headers({
"Accept: application/json",
})
ApiResponse getCsvDocumentationWithHttpInfo(@Param("name") String name);
/**
* Get a glossary by name
* Get a glossary by name.
* @param name Name of the glossary (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return Glossary
*/
@RequestLine("GET /v1/glossaries/name/{name}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryByFQN(@Param("name") String name, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary by name
* Similar to getGlossaryByFQN but it also returns the http response headers .
* Get a glossary by name.
* @param name Name of the glossary (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaries/name/{name}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryByFQNWithHttpInfo(@Param("name") String name, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary by name
* Get a glossary by name.
* Note, this is equivalent to the other getGlossaryByFQN method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link GetGlossaryByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param name Name of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaries/name/{name}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryByFQN(@Param("name") String name, @QueryMap(encoded=true) GetGlossaryByFQNQueryParams queryParams);
/**
* Get a glossary by name
* Get a glossary by name.
* Note, this is equivalent to the other getGlossaryByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param name Name of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaries/name/{name}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryByFQNWithHttpInfo(@Param("name") String name, @QueryMap(encoded=true) GetGlossaryByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getGlossaryByFQN method in a fluent style.
*/
public static class GetGlossaryByFQNQueryParams extends HashMap {
public GetGlossaryByFQNQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetGlossaryByFQNQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a glossary by Id
* Get a glossary by `Id`.
* @param id Id of the glossary (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return Glossary
*/
@RequestLine("GET /v1/glossaries/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryByID(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary by Id
* Similar to getGlossaryByID but it also returns the http response headers .
* Get a glossary by `Id`.
* @param id Id of the glossary (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaries/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryByIDWithHttpInfo(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary by Id
* Get a glossary by `Id`.
* Note, this is equivalent to the other getGlossaryByID method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link GetGlossaryByIDQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaries/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryByID(@Param("id") UUID id, @QueryMap(encoded=true) GetGlossaryByIDQueryParams queryParams);
/**
* Get a glossary by Id
* Get a glossary by `Id`.
* Note, this is equivalent to the other getGlossaryByID that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the glossary (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaries/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryByIDWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) GetGlossaryByIDQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getGlossaryByID method in a fluent style.
*/
public static class GetGlossaryByIDQueryParams extends HashMap {
public GetGlossaryByIDQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetGlossaryByIDQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a glossary term by fully qualified name
* Get a glossary term by `fullyQualifiedName`.
* @param fqn Fully qualified name of the glossary term (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return Glossary
*/
@RequestLine("GET /v1/glossaryTerms/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryTermByFQN(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary term by fully qualified name
* Similar to getGlossaryTermByFQN but it also returns the http response headers .
* Get a glossary term by `fullyQualifiedName`.
* @param fqn Fully qualified name of the glossary term (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaryTerms/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryTermByFQNWithHttpInfo(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary term by fully qualified name
* Get a glossary term by `fullyQualifiedName`.
* Note, this is equivalent to the other getGlossaryTermByFQN method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link GetGlossaryTermByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Fully qualified name of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaryTerms/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryTermByFQN(@Param("fqn") String fqn, @QueryMap(encoded=true) GetGlossaryTermByFQNQueryParams queryParams);
/**
* Get a glossary term by fully qualified name
* Get a glossary term by `fullyQualifiedName`.
* Note, this is equivalent to the other getGlossaryTermByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Fully qualified name of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaryTerms/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryTermByFQNWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) GetGlossaryTermByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getGlossaryTermByFQN method in a fluent style.
*/
public static class GetGlossaryTermByFQNQueryParams extends HashMap {
public GetGlossaryTermByFQNQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetGlossaryTermByFQNQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a glossary term by Id
* Get a glossary term by `Id`.
* @param id Id of the glossary term (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return Glossary
*/
@RequestLine("GET /v1/glossaryTerms/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryTermByID(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary term by Id
* Similar to getGlossaryTermByID but it also returns the http response headers .
* Get a glossary term by `Id`.
* @param id Id of the glossary term (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaryTerms/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryTermByIDWithHttpInfo(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a glossary term by Id
* Get a glossary term by `Id`.
* Note, this is equivalent to the other getGlossaryTermByID method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link GetGlossaryTermByIDQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaryTerms/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
Glossary getGlossaryTermByID(@Param("id") UUID id, @QueryMap(encoded=true) GetGlossaryTermByIDQueryParams queryParams);
/**
* Get a glossary term by Id
* Get a glossary term by `Id`.
* Note, this is equivalent to the other getGlossaryTermByID that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the glossary term (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return Glossary
*/
@RequestLine("GET /v1/glossaryTerms/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getGlossaryTermByIDWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) GetGlossaryTermByIDQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getGlossaryTermByID method in a fluent style.
*/
public static class GetGlossaryTermByIDQueryParams extends HashMap {
public GetGlossaryTermByIDQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetGlossaryTermByIDQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a version of the glossary term
* Get a version of the glossary term by given `Id`
* @param id Id of the glossary term (required)
* @param version glossary term version number in the form `major`.`minor` (required)
* @return Glossary
*/
@RequestLine("GET /v1/glossaryTerms/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
Glossary getSpecificGlossaryTermVersion(@Param("id") UUID id, @Param("version") String version);
/**
* Get a version of the glossary term
* Similar to getSpecificGlossaryTermVersion but it also returns the http response headers .
* Get a version of the glossary term by given `Id`
* @param id Id of the glossary term (required)
* @param version glossary term version number in the form `major`.`minor` (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaryTerms/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
ApiResponse getSpecificGlossaryTermVersionWithHttpInfo(@Param("id") UUID id, @Param("version") String version);
/**
* Get a version of the glossaries
* Get a version of the glossary by given `Id`
* @param id Id of the glossary (required)
* @param version glossary version number in the form `major`.`minor` (required)
* @return Glossary
*/
@RequestLine("GET /v1/glossaries/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
Glossary getSpecificGlossaryVersion(@Param("id") UUID id, @Param("version") String version);
/**
* Get a version of the glossaries
* Similar to getSpecificGlossaryVersion but it also returns the http response headers .
* Get a version of the glossary by given `Id`
* @param id Id of the glossary (required)
* @param version glossary version number in the form `major`.`minor` (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaries/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
ApiResponse getSpecificGlossaryVersionWithHttpInfo(@Param("id") UUID id, @Param("version") String version);
/**
* Import glossary terms from CSV to create, and update glossary terms
*
* @param name Name of the glossary (required)
* @param dryRun Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
* @param body (optional)
* @return CsvImportResult
*/
@RequestLine("PUT /v1/glossaries/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
CsvImportResult importGlossary(@Param("name") String name, @Param("dryRun") Boolean dryRun, String body);
/**
* Import glossary terms from CSV to create, and update glossary terms
* Similar to importGlossary but it also returns the http response headers .
*
* @param name Name of the glossary (required)
* @param dryRun Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
* @param body (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaries/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
ApiResponse importGlossaryWithHttpInfo(@Param("name") String name, @Param("dryRun") Boolean dryRun, String body);
/**
* Import glossary terms from CSV to create, and update glossary terms
*
* Note, this is equivalent to the other importGlossary method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link ImportGlossaryQueryParams} class that allows for
* building up this map in a fluent style.
* @param name Name of the glossary (required)
* @param body (optional)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - dryRun - Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
*
* @return CsvImportResult
*/
@RequestLine("PUT /v1/glossaries/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
CsvImportResult importGlossary(@Param("name") String name, String body, @QueryMap(encoded=true) ImportGlossaryQueryParams queryParams);
/**
* Import glossary terms from CSV to create, and update glossary terms
*
* Note, this is equivalent to the other importGlossary that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param name Name of the glossary (required)
* @param body (optional)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - dryRun - Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
*
* @return CsvImportResult
*/
@RequestLine("PUT /v1/glossaries/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
ApiResponse importGlossaryWithHttpInfo(@Param("name") String name, String body, @QueryMap(encoded=true) ImportGlossaryQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* importGlossary method in a fluent style.
*/
public static class ImportGlossaryQueryParams extends HashMap {
public ImportGlossaryQueryParams dryRun(final Boolean value) {
put("dryRun", EncodingUtils.encode(value));
return this;
}
}
/**
* List glossary term versions
* Get a list of all the versions of a glossary terms identified by `id`
* @param id Id of the glossary term (required)
* @return EntityHistory
*/
@RequestLine("GET /v1/glossaryTerms/{id}/versions")
@Headers({
"Accept: application/json",
})
EntityHistory listAllGlossaryTermVersion(@Param("id") UUID id);
/**
* List glossary term versions
* Similar to listAllGlossaryTermVersion but it also returns the http response headers .
* Get a list of all the versions of a glossary terms identified by `id`
* @param id Id of the glossary term (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaryTerms/{id}/versions")
@Headers({
"Accept: application/json",
})
ApiResponse listAllGlossaryTermVersionWithHttpInfo(@Param("id") UUID id);
/**
* List glossary versions
* Get a list of all the versions of a glossary identified by `id`
* @param id Id of the glossary (required)
* @return EntityHistory
*/
@RequestLine("GET /v1/glossaries/{id}/versions")
@Headers({
"Accept: application/json",
})
EntityHistory listAllGlossaryVersion(@Param("id") UUID id);
/**
* List glossary versions
* Similar to listAllGlossaryVersion but it also returns the http response headers .
* Get a list of all the versions of a glossary identified by `id`
* @param id Id of the glossary (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaries/{id}/versions")
@Headers({
"Accept: application/json",
})
ApiResponse listAllGlossaryVersionWithHttpInfo(@Param("id") UUID id);
/**
* List glossaries
* Get a list of glossaries. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* @param fields Fields requested in the returned resource (optional)
* @param limit Limit the number glossaries returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of glossaries before this cursor (optional)
* @param after Returns list of glossaries after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return GlossaryList
*/
@RequestLine("GET /v1/glossaries?fields={fields}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
GlossaryList listGlossaries(@Param("fields") String fields, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List glossaries
* Similar to listGlossaries but it also returns the http response headers .
* Get a list of glossaries. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* @param fields Fields requested in the returned resource (optional)
* @param limit Limit the number glossaries returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of glossaries before this cursor (optional)
* @param after Returns list of glossaries after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaries?fields={fields}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listGlossariesWithHttpInfo(@Param("fields") String fields, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List glossaries
* Get a list of glossaries. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* Note, this is equivalent to the other listGlossaries method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link ListGlossariesQueryParams} class that allows for
* building up this map in a fluent style.
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - limit - Limit the number glossaries returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of glossaries before this cursor (optional)
* - after - Returns list of glossaries after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return GlossaryList
*/
@RequestLine("GET /v1/glossaries?fields={fields}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
GlossaryList listGlossaries(@QueryMap(encoded=true) ListGlossariesQueryParams queryParams);
/**
* List glossaries
* Get a list of glossaries. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* Note, this is equivalent to the other listGlossaries that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - limit - Limit the number glossaries returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of glossaries before this cursor (optional)
* - after - Returns list of glossaries after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return GlossaryList
*/
@RequestLine("GET /v1/glossaries?fields={fields}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listGlossariesWithHttpInfo(@QueryMap(encoded=true) ListGlossariesQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* listGlossaries method in a fluent style.
*/
public static class ListGlossariesQueryParams extends HashMap {
public ListGlossariesQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public ListGlossariesQueryParams limit(final Integer value) {
put("limit", EncodingUtils.encode(value));
return this;
}
public ListGlossariesQueryParams before(final String value) {
put("before", EncodingUtils.encode(value));
return this;
}
public ListGlossariesQueryParams after(final String value) {
put("after", EncodingUtils.encode(value));
return this;
}
public ListGlossariesQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* List glossary terms
* Get a list of glossary terms. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* @param glossary List glossary terms filtered by glossary identified by Id given in `glossary` parameter. (optional)
* @param parent List glossary terms filtered by children of glossary term identified by Id given in `parent` parameter. (optional)
* @param fields Fields requested in the returned resource (optional)
* @param limit Limit the number glossary terms returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of glossary terms before this cursor (optional)
* @param after Returns list of glossary terms after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @param directChildrenOf List glossary terms filtered to retrieve the first level/immediate children of the glossary term `directChildrenOf` parameter. (optional)
* @return GlossaryTermList
*/
@RequestLine("GET /v1/glossaryTerms?glossary={glossary}&parent={parent}&fields={fields}&limit={limit}&before={before}&after={after}&include={include}&directChildrenOf={directChildrenOf}")
@Headers({
"Accept: application/json",
})
GlossaryTermList listGlossaryTerm(@Param("glossary") String glossary, @Param("parent") String parent, @Param("fields") String fields, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include, @Param("directChildrenOf") String directChildrenOf);
/**
* List glossary terms
* Similar to listGlossaryTerm but it also returns the http response headers .
* Get a list of glossary terms. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* @param glossary List glossary terms filtered by glossary identified by Id given in `glossary` parameter. (optional)
* @param parent List glossary terms filtered by children of glossary term identified by Id given in `parent` parameter. (optional)
* @param fields Fields requested in the returned resource (optional)
* @param limit Limit the number glossary terms returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of glossary terms before this cursor (optional)
* @param after Returns list of glossary terms after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @param directChildrenOf List glossary terms filtered to retrieve the first level/immediate children of the glossary term `directChildrenOf` parameter. (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/glossaryTerms?glossary={glossary}&parent={parent}&fields={fields}&limit={limit}&before={before}&after={after}&include={include}&directChildrenOf={directChildrenOf}")
@Headers({
"Accept: application/json",
})
ApiResponse listGlossaryTermWithHttpInfo(@Param("glossary") String glossary, @Param("parent") String parent, @Param("fields") String fields, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include, @Param("directChildrenOf") String directChildrenOf);
/**
* List glossary terms
* Get a list of glossary terms. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* Note, this is equivalent to the other listGlossaryTerm method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link ListGlossaryTermQueryParams} class that allows for
* building up this map in a fluent style.
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - glossary - List glossary terms filtered by glossary identified by Id given in `glossary` parameter. (optional)
* - parent - List glossary terms filtered by children of glossary term identified by Id given in `parent` parameter. (optional)
* - fields - Fields requested in the returned resource (optional)
* - limit - Limit the number glossary terms returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of glossary terms before this cursor (optional)
* - after - Returns list of glossary terms after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* - directChildrenOf - List glossary terms filtered to retrieve the first level/immediate children of the glossary term `directChildrenOf` parameter. (optional)
*
* @return GlossaryTermList
*/
@RequestLine("GET /v1/glossaryTerms?glossary={glossary}&parent={parent}&fields={fields}&limit={limit}&before={before}&after={after}&include={include}&directChildrenOf={directChildrenOf}")
@Headers({
"Accept: application/json",
})
GlossaryTermList listGlossaryTerm(@QueryMap(encoded=true) ListGlossaryTermQueryParams queryParams);
/**
* List glossary terms
* Get a list of glossary terms. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* Note, this is equivalent to the other listGlossaryTerm that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - glossary - List glossary terms filtered by glossary identified by Id given in `glossary` parameter. (optional)
* - parent - List glossary terms filtered by children of glossary term identified by Id given in `parent` parameter. (optional)
* - fields - Fields requested in the returned resource (optional)
* - limit - Limit the number glossary terms returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of glossary terms before this cursor (optional)
* - after - Returns list of glossary terms after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* - directChildrenOf - List glossary terms filtered to retrieve the first level/immediate children of the glossary term `directChildrenOf` parameter. (optional)
*
* @return GlossaryTermList
*/
@RequestLine("GET /v1/glossaryTerms?glossary={glossary}&parent={parent}&fields={fields}&limit={limit}&before={before}&after={after}&include={include}&directChildrenOf={directChildrenOf}")
@Headers({
"Accept: application/json",
})
ApiResponse listGlossaryTermWithHttpInfo(@QueryMap(encoded=true) ListGlossaryTermQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* listGlossaryTerm method in a fluent style.
*/
public static class ListGlossaryTermQueryParams extends HashMap {
public ListGlossaryTermQueryParams glossary(final String value) {
put("glossary", EncodingUtils.encode(value));
return this;
}
public ListGlossaryTermQueryParams parent(final String value) {
put("parent", EncodingUtils.encode(value));
return this;
}
public ListGlossaryTermQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public ListGlossaryTermQueryParams limit(final Integer value) {
put("limit", EncodingUtils.encode(value));
return this;
}
public ListGlossaryTermQueryParams before(final String value) {
put("before", EncodingUtils.encode(value));
return this;
}
public ListGlossaryTermQueryParams after(final String value) {
put("after", EncodingUtils.encode(value));
return this;
}
public ListGlossaryTermQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
public ListGlossaryTermQueryParams directChildrenOf(final String value) {
put("directChildrenOf", EncodingUtils.encode(value));
return this;
}
}
/**
* Update a glossary using name.
* Update an existing glossary using JsonPatch.
* @param fqn Name of the glossary (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary using name. Documentation
*/
@RequestLine("PATCH /v1/glossaries/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchGlossary(@Param("fqn") String fqn, Object body);
/**
* Update a glossary using name.
* Similar to patchGlossary but it also returns the http response headers .
* Update an existing glossary using JsonPatch.
* @param fqn Name of the glossary (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary using name. Documentation
*/
@RequestLine("PATCH /v1/glossaries/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchGlossaryWithHttpInfo(@Param("fqn") String fqn, Object body);
/**
* Update a glossary
* Update an existing glossary using JsonPatch.
* @param id Id of the glossary (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary Documentation
*/
@RequestLine("PATCH /v1/glossaries/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchGlossary1(@Param("id") UUID id, Object body);
/**
* Update a glossary
* Similar to patchGlossary1 but it also returns the http response headers .
* Update an existing glossary using JsonPatch.
* @param id Id of the glossary (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary Documentation
*/
@RequestLine("PATCH /v1/glossaries/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchGlossary1WithHttpInfo(@Param("id") UUID id, Object body);
/**
* Update a glossary term by name.
* Update an existing glossary term using JsonPatch.
* @param fqn Name of the glossary term (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary term by name. Documentation
*/
@RequestLine("PATCH /v1/glossaryTerms/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchGlossaryTerm(@Param("fqn") String fqn, Object body);
/**
* Update a glossary term by name.
* Similar to patchGlossaryTerm but it also returns the http response headers .
* Update an existing glossary term using JsonPatch.
* @param fqn Name of the glossary term (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary term by name. Documentation
*/
@RequestLine("PATCH /v1/glossaryTerms/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchGlossaryTermWithHttpInfo(@Param("fqn") String fqn, Object body);
/**
* Update a glossary term
* Update an existing glossary term using JsonPatch.
* @param id Id of the glossary term (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary term Documentation
*/
@RequestLine("PATCH /v1/glossaryTerms/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchGlossaryTerm1(@Param("id") UUID id, Object body);
/**
* Update a glossary term
* Similar to patchGlossaryTerm1 but it also returns the http response headers .
* Update an existing glossary term using JsonPatch.
* @param id Id of the glossary term (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a glossary term Documentation
*/
@RequestLine("PATCH /v1/glossaryTerms/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchGlossaryTerm1WithHttpInfo(@Param("id") UUID id, Object body);
/**
* Restore a soft deleted glossary
* Restore a soft deleted Glossary.
* @param restoreEntity (optional)
* @return Glossary
*/
@RequestLine("PUT /v1/glossaries/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
Glossary restore13(RestoreEntity restoreEntity);
/**
* Restore a soft deleted glossary
* Similar to restore13 but it also returns the http response headers .
* Restore a soft deleted Glossary.
* @param restoreEntity (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaries/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse restore13WithHttpInfo(RestoreEntity restoreEntity);
/**
* Restore a soft deleted glossary term
* Restore a soft deleted glossary term.
* @param restoreEntity (optional)
* @return GlossaryTerm
*/
@RequestLine("PUT /v1/glossaryTerms/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
GlossaryTerm restore14(RestoreEntity restoreEntity);
/**
* Restore a soft deleted glossary term
* Similar to restore14 but it also returns the http response headers .
* Restore a soft deleted glossary term.
* @param restoreEntity (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaryTerms/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse restore14WithHttpInfo(RestoreEntity restoreEntity);
/**
* Update Vote for a Entity
* Update vote for a Entity
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return ChangeEvent
*/
@RequestLine("PUT /v1/glossaries/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ChangeEvent updateVoteForEntity7(@Param("id") UUID id, VoteRequest voteRequest);
/**
* Update Vote for a Entity
* Similar to updateVoteForEntity7 but it also returns the http response headers .
* Update vote for a Entity
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaries/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse updateVoteForEntity7WithHttpInfo(@Param("id") UUID id, VoteRequest voteRequest);
/**
* Update Vote for a Entity
* Update vote for a Entity
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return ChangeEvent
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ChangeEvent updateVoteForEntity8(@Param("id") UUID id, VoteRequest voteRequest);
/**
* Update Vote for a Entity
* Similar to updateVoteForEntity8 but it also returns the http response headers .
* Update vote for a Entity
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse updateVoteForEntity8WithHttpInfo(@Param("id") UUID id, VoteRequest voteRequest);
/**
* Validate Tags Addition to Glossary Term
* Validate Tags Addition to Glossary Term
* @param id Id of the Entity (required)
* @param addGlossaryToAssetsRequest (optional)
* @return BulkOperationResult
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/tags/validate")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
BulkOperationResult validateGlossaryTermTagsAddition(@Param("id") UUID id, AddGlossaryToAssetsRequest addGlossaryToAssetsRequest);
/**
* Validate Tags Addition to Glossary Term
* Similar to validateGlossaryTermTagsAddition but it also returns the http response headers .
* Validate Tags Addition to Glossary Term
* @param id Id of the Entity (required)
* @param addGlossaryToAssetsRequest (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/glossaryTerms/{id}/tags/validate")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse validateGlossaryTermTagsAdditionWithHttpInfo(@Param("id") UUID id, AddGlossaryToAssetsRequest addGlossaryToAssetsRequest);
}