org.openmetadata.client.api.ApiCollectionsApi 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.APICollection;
import org.openmetadata.client.model.APICollectionList;
import org.openmetadata.client.model.ChangeEvent;
import org.openmetadata.client.model.CreateAPICollection;
import org.openmetadata.client.model.Database;
import org.openmetadata.client.model.EntityHistory;
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-09-13T20:15:57.513387948Z[Etc/UTC]")
public interface ApiCollectionsApi extends ApiClient.Api {
/**
* Create a APICollection
* Create a APICollection under an existing `service`.
* @param createAPICollection (optional)
* @return Database
*/
@RequestLine("POST /v1/apiCollections")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
Database createAPICollection(CreateAPICollection createAPICollection);
/**
* Create a APICollection
* Similar to createAPICollection but it also returns the http response headers .
* Create a APICollection under an existing `service`.
* @param createAPICollection (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("POST /v1/apiCollections")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createAPICollectionWithHttpInfo(CreateAPICollection createAPICollection);
/**
* Create or update API Collection
* Create a API Collection, if it does not exist or update an existing API Collection.
* @param createAPICollection (optional)
* @return APICollection
*/
@RequestLine("PUT /v1/apiCollections")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
APICollection createOrUpdateAPICollection(CreateAPICollection createAPICollection);
/**
* Create or update API Collection
* Similar to createOrUpdateAPICollection but it also returns the http response headers .
* Create a API Collection, if it does not exist or update an existing API Collection.
* @param createAPICollection (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/apiCollections")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createOrUpdateAPICollectionWithHttpInfo(CreateAPICollection createAPICollection);
/**
* Delete a API Collection by Id
* Delete a API Collection by `Id`. API Collection can only be deleted if it has no tables.
* @param id Id of the database (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/apiCollections/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteAPICollection(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a API Collection by Id
* Similar to deleteAPICollection but it also returns the http response headers .
* Delete a API Collection by `Id`. API Collection can only be deleted if it has no tables.
* @param id Id of the database (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/apiCollections/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPICollectionWithHttpInfo(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a API Collection by Id
* Delete a API Collection by `Id`. API Collection can only be deleted if it has no tables.
* Note, this is equivalent to the other deleteAPICollection 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 DeleteAPICollectionQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the database (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/apiCollections/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteAPICollection(@Param("id") UUID id, @QueryMap(encoded=true) DeleteAPICollectionQueryParams queryParams);
/**
* Delete a API Collection by Id
* Delete a API Collection by `Id`. API Collection can only be deleted if it has no tables.
* Note, this is equivalent to the other deleteAPICollection that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the database (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/apiCollections/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPICollectionWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) DeleteAPICollectionQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteAPICollection method in a fluent style.
*/
public static class DeleteAPICollectionQueryParams extends HashMap {
public DeleteAPICollectionQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
public DeleteAPICollectionQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
}
/**
* Delete a API Collection by fully qualified name
* Delete a API Collection by `fullyQualifiedName`. API Collection can only be deleted if it has no API Endpoints.
* @param fqn Fully qualified name of the database (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/apiCollections/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteAPICollectionByFQN(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a API Collection by fully qualified name
* Similar to deleteAPICollectionByFQN but it also returns the http response headers .
* Delete a API Collection by `fullyQualifiedName`. API Collection can only be deleted if it has no API Endpoints.
* @param fqn Fully qualified name of the database (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/apiCollections/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPICollectionByFQNWithHttpInfo(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a API Collection by fully qualified name
* Delete a API Collection by `fullyQualifiedName`. API Collection can only be deleted if it has no API Endpoints.
* Note, this is equivalent to the other deleteAPICollectionByFQN 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 DeleteAPICollectionByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Fully qualified name of the database (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/apiCollections/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteAPICollectionByFQN(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteAPICollectionByFQNQueryParams queryParams);
/**
* Delete a API Collection by fully qualified name
* Delete a API Collection by `fullyQualifiedName`. API Collection can only be deleted if it has no API Endpoints.
* Note, this is equivalent to the other deleteAPICollectionByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Fully qualified name of the database (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/apiCollections/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPICollectionByFQNWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteAPICollectionByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteAPICollectionByFQN method in a fluent style.
*/
public static class DeleteAPICollectionByFQNQueryParams extends HashMap {
public DeleteAPICollectionByFQNQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
public DeleteAPICollectionByFQNQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a APICollection by fully qualified name
* Get a APICollection by `fullyQualifiedName`.
* @param fqn Fully qualified name of the APICollection (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 APICollection
*/
@RequestLine("GET /v1/apiCollections/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APICollection getAPICollectionByFQN(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a APICollection by fully qualified name
* Similar to getAPICollectionByFQN but it also returns the http response headers .
* Get a APICollection by `fullyQualifiedName`.
* @param fqn Fully qualified name of the APICollection (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/apiCollections/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getAPICollectionByFQNWithHttpInfo(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a APICollection by fully qualified name
* Get a APICollection by `fullyQualifiedName`.
* Note, this is equivalent to the other getAPICollectionByFQN 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 GetAPICollectionByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Fully qualified name of the APICollection (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 APICollection
*/
@RequestLine("GET /v1/apiCollections/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APICollection getAPICollectionByFQN(@Param("fqn") String fqn, @QueryMap(encoded=true) GetAPICollectionByFQNQueryParams queryParams);
/**
* Get a APICollection by fully qualified name
* Get a APICollection by `fullyQualifiedName`.
* Note, this is equivalent to the other getAPICollectionByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Fully qualified name of the APICollection (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 APICollection
*/
@RequestLine("GET /v1/apiCollections/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getAPICollectionByFQNWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) GetAPICollectionByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getAPICollectionByFQN method in a fluent style.
*/
public static class GetAPICollectionByFQNQueryParams extends HashMap {
public GetAPICollectionByFQNQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetAPICollectionByFQNQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a API Collection by Id
* Get a API Collection by `Id`.
* @param id Id of the APICollection (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 APICollection
*/
@RequestLine("GET /v1/apiCollections/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APICollection getAPICollectionByID(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a API Collection by Id
* Similar to getAPICollectionByID but it also returns the http response headers .
* Get a API Collection by `Id`.
* @param id Id of the APICollection (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/apiCollections/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getAPICollectionByIDWithHttpInfo(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a API Collection by Id
* Get a API Collection by `Id`.
* Note, this is equivalent to the other getAPICollectionByID 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 GetAPICollectionByIDQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the APICollection (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 APICollection
*/
@RequestLine("GET /v1/apiCollections/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APICollection getAPICollectionByID(@Param("id") UUID id, @QueryMap(encoded=true) GetAPICollectionByIDQueryParams queryParams);
/**
* Get a API Collection by Id
* Get a API Collection by `Id`.
* Note, this is equivalent to the other getAPICollectionByID that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the APICollection (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 APICollection
*/
@RequestLine("GET /v1/apiCollections/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getAPICollectionByIDWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) GetAPICollectionByIDQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getAPICollectionByID method in a fluent style.
*/
public static class GetAPICollectionByIDQueryParams extends HashMap {
public GetAPICollectionByIDQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetAPICollectionByIDQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a version of the APICollection
* Get a version of the APICollection by given `Id`
* @param id Id of the APICollection (required)
* @param version APICollection version number in the form `major`.`minor` (required)
* @return APICollection
*/
@RequestLine("GET /v1/apiCollections/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
APICollection getSpecificAPICollectionVersion(@Param("id") UUID id, @Param("version") String version);
/**
* Get a version of the APICollection
* Similar to getSpecificAPICollectionVersion but it also returns the http response headers .
* Get a version of the APICollection by given `Id`
* @param id Id of the APICollection (required)
* @param version APICollection version number in the form `major`.`minor` (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/apiCollections/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
ApiResponse getSpecificAPICollectionVersionWithHttpInfo(@Param("id") UUID id, @Param("version") String version);
/**
* List API Collections
* Get a list of API Collections, optionally filtered by `service` it belongs to. 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 service Filter APICollection by service name (optional)
* @param limit Limit the number APICollections returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of API Collections before this cursor (optional)
* @param after Returns list of API Collections after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return APICollectionList
*/
@RequestLine("GET /v1/apiCollections?fields={fields}&service={service}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
APICollectionList listAPICollections(@Param("fields") String fields, @Param("service") String service, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List API Collections
* Similar to listAPICollections but it also returns the http response headers .
* Get a list of API Collections, optionally filtered by `service` it belongs to. 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 service Filter APICollection by service name (optional)
* @param limit Limit the number APICollections returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of API Collections before this cursor (optional)
* @param after Returns list of API Collections 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/apiCollections?fields={fields}&service={service}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listAPICollectionsWithHttpInfo(@Param("fields") String fields, @Param("service") String service, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List API Collections
* Get a list of API Collections, optionally filtered by `service` it belongs to. 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 listAPICollections 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 ListAPICollectionsQueryParams} 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)
* - service - Filter APICollection by service name (optional)
* - limit - Limit the number APICollections returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of API Collections before this cursor (optional)
* - after - Returns list of API Collections after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return APICollectionList
*/
@RequestLine("GET /v1/apiCollections?fields={fields}&service={service}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
APICollectionList listAPICollections(@QueryMap(encoded=true) ListAPICollectionsQueryParams queryParams);
/**
* List API Collections
* Get a list of API Collections, optionally filtered by `service` it belongs to. 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 listAPICollections 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)
* - service - Filter APICollection by service name (optional)
* - limit - Limit the number APICollections returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of API Collections before this cursor (optional)
* - after - Returns list of API Collections after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return APICollectionList
*/
@RequestLine("GET /v1/apiCollections?fields={fields}&service={service}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listAPICollectionsWithHttpInfo(@QueryMap(encoded=true) ListAPICollectionsQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* listAPICollections method in a fluent style.
*/
public static class ListAPICollectionsQueryParams extends HashMap {
public ListAPICollectionsQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public ListAPICollectionsQueryParams service(final String value) {
put("service", EncodingUtils.encode(value));
return this;
}
public ListAPICollectionsQueryParams limit(final Integer value) {
put("limit", EncodingUtils.encode(value));
return this;
}
public ListAPICollectionsQueryParams before(final String value) {
put("before", EncodingUtils.encode(value));
return this;
}
public ListAPICollectionsQueryParams after(final String value) {
put("after", EncodingUtils.encode(value));
return this;
}
public ListAPICollectionsQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* List API Collection versions
* Get a list of all the versions of a API Collection identified by `Id`
* @param id Id of the API Collection (required)
* @return EntityHistory
*/
@RequestLine("GET /v1/apiCollections/{id}/versions")
@Headers({
"Accept: application/json",
})
EntityHistory listAllAPICollectionVersion(@Param("id") UUID id);
/**
* List API Collection versions
* Similar to listAllAPICollectionVersion but it also returns the http response headers .
* Get a list of all the versions of a API Collection identified by `Id`
* @param id Id of the API Collection (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/apiCollections/{id}/versions")
@Headers({
"Accept: application/json",
})
ApiResponse listAllAPICollectionVersionWithHttpInfo(@Param("id") UUID id);
/**
* Update a APICollection by name.
* Update an existing APICollection using JsonPatch.
* @param fqn Name of the API Collection (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a APICollection by name. Documentation
*/
@RequestLine("PATCH /v1/apiCollections/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchAPICollection(@Param("fqn") String fqn, Object body);
/**
* Update a APICollection by name.
* Similar to patchAPICollection but it also returns the http response headers .
* Update an existing APICollection using JsonPatch.
* @param fqn Name of the API Collection (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a APICollection by name. Documentation
*/
@RequestLine("PATCH /v1/apiCollections/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchAPICollectionWithHttpInfo(@Param("fqn") String fqn, Object body);
/**
* Update a API Collection by Id
* Update an existing API Collection using JsonPatch.
* @param id Id of the API Collection (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a API Collection by Id Documentation
*/
@RequestLine("PATCH /v1/apiCollections/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchAPICollection1(@Param("id") UUID id, Object body);
/**
* Update a API Collection by Id
* Similar to patchAPICollection1 but it also returns the http response headers .
* Update an existing API Collection using JsonPatch.
* @param id Id of the API Collection (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a API Collection by Id Documentation
*/
@RequestLine("PATCH /v1/apiCollections/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchAPICollection1WithHttpInfo(@Param("id") UUID id, Object body);
/**
* Restore a soft deleted API Collection.
* Restore a soft deleted API Collection.
* @param restoreEntity (optional)
* @return APICollection
*/
@RequestLine("PUT /v1/apiCollections/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
APICollection restore(RestoreEntity restoreEntity);
/**
* Restore a soft deleted API Collection.
* Similar to restore but it also returns the http response headers .
* Restore a soft deleted API Collection.
* @param restoreEntity (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/apiCollections/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse restoreWithHttpInfo(RestoreEntity restoreEntity);
/**
* Update Vote for a API Collection
* Update vote for a API Collection
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return ChangeEvent
*/
@RequestLine("PUT /v1/apiCollections/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ChangeEvent updateVoteForAPICollection(@Param("id") UUID id, VoteRequest voteRequest);
/**
* Update Vote for a API Collection
* Similar to updateVoteForAPICollection but it also returns the http response headers .
* Update vote for a API Collection
* @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/apiCollections/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse updateVoteForAPICollectionWithHttpInfo(@Param("id") UUID id, VoteRequest voteRequest);
}