org.openmetadata.client.api.ApiEndpointApi 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.APIEndpoint;
import org.openmetadata.client.model.APIEndpointList;
import org.openmetadata.client.model.ChangeEvent;
import org.openmetadata.client.model.CreateAPIEndpoint;
import org.openmetadata.client.model.EntityHistory;
import org.openmetadata.client.model.RestoreEntity;
import org.openmetadata.client.model.Topic;
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 ApiEndpointApi extends ApiClient.Api {
/**
* Add a follower
* Add a user identified by `userId` as followed of this APiEndpoint.
* @param id Id of the APIEndpoint (required)
* @param body Id of the user to be added as follower (optional)
* @return ChangeEvent
*/
@RequestLine("PUT /v1/apiEndpoints/{id}/followers")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ChangeEvent addFollower(@Param("id") UUID id, UUID body);
/**
* Add a follower
* Similar to addFollower but it also returns the http response headers .
* Add a user identified by `userId` as followed of this APiEndpoint.
* @param id Id of the APIEndpoint (required)
* @param body Id of the user to be added as follower (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/apiEndpoints/{id}/followers")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse addFollowerWithHttpInfo(@Param("id") UUID id, UUID body);
/**
* Create a API Endpoint
* Create a API Endpoint under an existing `service`.
* @param createAPIEndpoint (optional)
* @return APIEndpoint
*/
@RequestLine("POST /v1/apiEndpoints")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
APIEndpoint createAPIEndpoint(CreateAPIEndpoint createAPIEndpoint);
/**
* Create a API Endpoint
* Similar to createAPIEndpoint but it also returns the http response headers .
* Create a API Endpoint under an existing `service`.
* @param createAPIEndpoint (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("POST /v1/apiEndpoints")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createAPIEndpointWithHttpInfo(CreateAPIEndpoint createAPIEndpoint);
/**
* Update topic
* Create a API Endpoint, it it does not exist or update an existing API Endpoint.
* @param createAPIEndpoint (optional)
* @return Topic
*/
@RequestLine("PUT /v1/apiEndpoints")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
Topic createOrUpdateAPIEndpoint(CreateAPIEndpoint createAPIEndpoint);
/**
* Update topic
* Similar to createOrUpdateAPIEndpoint but it also returns the http response headers .
* Create a API Endpoint, it it does not exist or update an existing API Endpoint.
* @param createAPIEndpoint (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/apiEndpoints")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createOrUpdateAPIEndpointWithHttpInfo(CreateAPIEndpoint createAPIEndpoint);
/**
* Delete a APIEndpoint by id
* Delete a APIEndpoint by `id`.
* @param id Id of the APIEndpoint (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/apiEndpoints/{id}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteAPIEndpoint(@Param("id") UUID id, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a APIEndpoint by id
* Similar to deleteAPIEndpoint but it also returns the http response headers .
* Delete a APIEndpoint by `id`.
* @param id Id of the APIEndpoint (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/apiEndpoints/{id}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPIEndpointWithHttpInfo(@Param("id") UUID id, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a APIEndpoint by id
* Delete a APIEndpoint by `id`.
* Note, this is equivalent to the other deleteAPIEndpoint 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 DeleteAPIEndpointQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the APIEndpoint (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)
*
*/
@RequestLine("DELETE /v1/apiEndpoints/{id}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteAPIEndpoint(@Param("id") UUID id, @QueryMap(encoded=true) DeleteAPIEndpointQueryParams queryParams);
/**
* Delete a APIEndpoint by id
* Delete a APIEndpoint by `id`.
* Note, this is equivalent to the other deleteAPIEndpoint that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the APIEndpoint (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)
*
*/
@RequestLine("DELETE /v1/apiEndpoints/{id}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPIEndpointWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) DeleteAPIEndpointQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteAPIEndpoint method in a fluent style.
*/
public static class DeleteAPIEndpointQueryParams extends HashMap {
public DeleteAPIEndpointQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
}
/**
* Delete a APIEndpoint by fully qualified name
* Delete a APIEndpoint by `fullyQualifiedName`.
* @param fqn Fully qualified name of the APIEndpoint (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/apiEndpoints/name/{fqn}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteAPIEndpointByFQN(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a APIEndpoint by fully qualified name
* Similar to deleteAPIEndpointByFQN but it also returns the http response headers .
* Delete a APIEndpoint by `fullyQualifiedName`.
* @param fqn Fully qualified name of the APIEndpoint (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/apiEndpoints/name/{fqn}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPIEndpointByFQNWithHttpInfo(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a APIEndpoint by fully qualified name
* Delete a APIEndpoint by `fullyQualifiedName`.
* Note, this is equivalent to the other deleteAPIEndpointByFQN 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 DeleteAPIEndpointByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Fully qualified name of the APIEndpoint (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)
*
*/
@RequestLine("DELETE /v1/apiEndpoints/name/{fqn}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteAPIEndpointByFQN(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteAPIEndpointByFQNQueryParams queryParams);
/**
* Delete a APIEndpoint by fully qualified name
* Delete a APIEndpoint by `fullyQualifiedName`.
* Note, this is equivalent to the other deleteAPIEndpointByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Fully qualified name of the APIEndpoint (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)
*
*/
@RequestLine("DELETE /v1/apiEndpoints/name/{fqn}?hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteAPIEndpointByFQNWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteAPIEndpointByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteAPIEndpointByFQN method in a fluent style.
*/
public static class DeleteAPIEndpointByFQNQueryParams extends HashMap {
public DeleteAPIEndpointByFQNQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
}
/**
* Remove a follower
* Remove the user identified `userId` as a follower of the APIEndpoint.
* @param id Id of the APIEndpoint (required)
* @param userId Id of the user being removed as follower (required)
* @return ChangeEvent
*/
@RequestLine("DELETE /v1/apiEndpoints/{id}/followers/{userId}")
@Headers({
"Accept: application/json",
})
ChangeEvent deleteFollower(@Param("id") UUID id, @Param("userId") String userId);
/**
* Remove a follower
* Similar to deleteFollower but it also returns the http response headers .
* Remove the user identified `userId` as a follower of the APIEndpoint.
* @param id Id of the APIEndpoint (required)
* @param userId Id of the user being removed as follower (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("DELETE /v1/apiEndpoints/{id}/followers/{userId}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteFollowerWithHttpInfo(@Param("id") UUID id, @Param("userId") String userId);
/**
* Get a Endpoint by fully qualified name.
* Get a Endpoint by fully qualified name.
* @param fqn Fully qualified name of the Endpoint (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 APIEndpoint
*/
@RequestLine("GET /v1/apiEndpoints/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APIEndpoint getEndpointByFQN(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a Endpoint by fully qualified name.
* Similar to getEndpointByFQN but it also returns the http response headers .
* Get a Endpoint by fully qualified name.
* @param fqn Fully qualified name of the Endpoint (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/apiEndpoints/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getEndpointByFQNWithHttpInfo(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a Endpoint by fully qualified name.
* Get a Endpoint by fully qualified name.
* Note, this is equivalent to the other getEndpointByFQN 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 GetEndpointByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Fully qualified name of the Endpoint (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 APIEndpoint
*/
@RequestLine("GET /v1/apiEndpoints/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APIEndpoint getEndpointByFQN(@Param("fqn") String fqn, @QueryMap(encoded=true) GetEndpointByFQNQueryParams queryParams);
/**
* Get a Endpoint by fully qualified name.
* Get a Endpoint by fully qualified name.
* Note, this is equivalent to the other getEndpointByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Fully qualified name of the Endpoint (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 APIEndpoint
*/
@RequestLine("GET /v1/apiEndpoints/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getEndpointByFQNWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) GetEndpointByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getEndpointByFQN method in a fluent style.
*/
public static class GetEndpointByFQNQueryParams extends HashMap {
public GetEndpointByFQNQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetEndpointByFQNQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a APIEndpoint by id
* Get a APIEndpoint by `id`.
* @param id Id of the APIEndpoint (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 APIEndpoint
*/
@RequestLine("GET /v1/apiEndpoints/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APIEndpoint getEndpointById(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a APIEndpoint by id
* Similar to getEndpointById but it also returns the http response headers .
* Get a APIEndpoint by `id`.
* @param id Id of the APIEndpoint (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/apiEndpoints/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getEndpointByIdWithHttpInfo(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a APIEndpoint by id
* Get a APIEndpoint by `id`.
* Note, this is equivalent to the other getEndpointById 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 GetEndpointByIdQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Id of the APIEndpoint (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 APIEndpoint
*/
@RequestLine("GET /v1/apiEndpoints/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
APIEndpoint getEndpointById(@Param("id") UUID id, @QueryMap(encoded=true) GetEndpointByIdQueryParams queryParams);
/**
* Get a APIEndpoint by id
* Get a APIEndpoint by `id`.
* Note, this is equivalent to the other getEndpointById that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Id of the APIEndpoint (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 APIEndpoint
*/
@RequestLine("GET /v1/apiEndpoints/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getEndpointByIdWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) GetEndpointByIdQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getEndpointById method in a fluent style.
*/
public static class GetEndpointByIdQueryParams extends HashMap {
public GetEndpointByIdQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetEndpointByIdQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a version of the APIEndpoint
* Get a version of the APIEndpoint by given `id`
* @param id Id of the APIEndpoint (required)
* @param version APIEndpoint version number in the form `major`.`minor` (required)
* @return APIEndpoint
*/
@RequestLine("GET /v1/apiEndpoints/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
APIEndpoint getSpecificEndpointVersion(@Param("id") UUID id, @Param("version") String version);
/**
* Get a version of the APIEndpoint
* Similar to getSpecificEndpointVersion but it also returns the http response headers .
* Get a version of the APIEndpoint by given `id`
* @param id Id of the APIEndpoint (required)
* @param version APIEndpoint version number in the form `major`.`minor` (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/apiEndpoints/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
ApiResponse getSpecificEndpointVersionWithHttpInfo(@Param("id") UUID id, @Param("version") String version);
/**
* List API Endpoints
* Get a list of API Endpoints, 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 APIEndpoints by service name (optional)
* @param apiCollection Filter APIEndpoints by apiCollection name (optional)
* @param limit Limit the number APIEndpoints returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of APIEndpoints before this cursor (optional)
* @param after Returns list of APIEndpoints after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return APIEndpointList
*/
@RequestLine("GET /v1/apiEndpoints?fields={fields}&service={service}&apiCollection={apiCollection}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
APIEndpointList listAPIEndpoints(@Param("fields") String fields, @Param("service") String service, @Param("apiCollection") String apiCollection, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List API Endpoints
* Similar to listAPIEndpoints but it also returns the http response headers .
* Get a list of API Endpoints, 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 APIEndpoints by service name (optional)
* @param apiCollection Filter APIEndpoints by apiCollection name (optional)
* @param limit Limit the number APIEndpoints returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of APIEndpoints before this cursor (optional)
* @param after Returns list of APIEndpoints 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/apiEndpoints?fields={fields}&service={service}&apiCollection={apiCollection}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listAPIEndpointsWithHttpInfo(@Param("fields") String fields, @Param("service") String service, @Param("apiCollection") String apiCollection, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List API Endpoints
* Get a list of API Endpoints, 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 listAPIEndpoints 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 ListAPIEndpointsQueryParams} 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 APIEndpoints by service name (optional)
* - apiCollection - Filter APIEndpoints by apiCollection name (optional)
* - limit - Limit the number APIEndpoints returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of APIEndpoints before this cursor (optional)
* - after - Returns list of APIEndpoints after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return APIEndpointList
*/
@RequestLine("GET /v1/apiEndpoints?fields={fields}&service={service}&apiCollection={apiCollection}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
APIEndpointList listAPIEndpoints(@QueryMap(encoded=true) ListAPIEndpointsQueryParams queryParams);
/**
* List API Endpoints
* Get a list of API Endpoints, 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 listAPIEndpoints 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 APIEndpoints by service name (optional)
* - apiCollection - Filter APIEndpoints by apiCollection name (optional)
* - limit - Limit the number APIEndpoints returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of APIEndpoints before this cursor (optional)
* - after - Returns list of APIEndpoints after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return APIEndpointList
*/
@RequestLine("GET /v1/apiEndpoints?fields={fields}&service={service}&apiCollection={apiCollection}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listAPIEndpointsWithHttpInfo(@QueryMap(encoded=true) ListAPIEndpointsQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* listAPIEndpoints method in a fluent style.
*/
public static class ListAPIEndpointsQueryParams extends HashMap {
public ListAPIEndpointsQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public ListAPIEndpointsQueryParams service(final String value) {
put("service", EncodingUtils.encode(value));
return this;
}
public ListAPIEndpointsQueryParams apiCollection(final String value) {
put("apiCollection", EncodingUtils.encode(value));
return this;
}
public ListAPIEndpointsQueryParams limit(final Integer value) {
put("limit", EncodingUtils.encode(value));
return this;
}
public ListAPIEndpointsQueryParams before(final String value) {
put("before", EncodingUtils.encode(value));
return this;
}
public ListAPIEndpointsQueryParams after(final String value) {
put("after", EncodingUtils.encode(value));
return this;
}
public ListAPIEndpointsQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* List API Endpoint versions
* Get a list of all the versions of a APIEndpoint identified by `id`
* @param id Id of the APIEndpoint (required)
* @return EntityHistory
*/
@RequestLine("GET /v1/apiEndpoints/{id}/versions")
@Headers({
"Accept: application/json",
})
EntityHistory listAllAPIEndpointVersion(@Param("id") UUID id);
/**
* List API Endpoint versions
* Similar to listAllAPIEndpointVersion but it also returns the http response headers .
* Get a list of all the versions of a APIEndpoint identified by `id`
* @param id Id of the APIEndpoint (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/apiEndpoints/{id}/versions")
@Headers({
"Accept: application/json",
})
ApiResponse listAllAPIEndpointVersionWithHttpInfo(@Param("id") UUID id);
/**
* Update a APIEndpoint using name.
* Update an existing APIEndpoint using JsonPatch.
* @param fqn Name of the topic (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a APIEndpoint using name. Documentation
*/
@RequestLine("PATCH /v1/apiEndpoints/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchAPIEndpoint(@Param("fqn") String fqn, Object body);
/**
* Update a APIEndpoint using name.
* Similar to patchAPIEndpoint but it also returns the http response headers .
* Update an existing APIEndpoint using JsonPatch.
* @param fqn Name of the topic (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a APIEndpoint using name. Documentation
*/
@RequestLine("PATCH /v1/apiEndpoints/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchAPIEndpointWithHttpInfo(@Param("fqn") String fqn, Object body);
/**
* Update a APIEndpoint
* Update an existing APIEndpoint using JsonPatch.
* @param id Id of the APIEndpoint (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a APIEndpoint Documentation
*/
@RequestLine("PATCH /v1/apiEndpoints/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchAPIEndpoint1(@Param("id") UUID id, Object body);
/**
* Update a APIEndpoint
* Similar to patchAPIEndpoint1 but it also returns the http response headers .
* Update an existing APIEndpoint using JsonPatch.
* @param id Id of the APIEndpoint (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a APIEndpoint Documentation
*/
@RequestLine("PATCH /v1/apiEndpoints/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchAPIEndpoint1WithHttpInfo(@Param("id") UUID id, Object body);
/**
* Restore a soft deleted APIEndpoint
* Restore a soft deleted APIEndpoint.
* @param restoreEntity (optional)
* @return APIEndpoint
*/
@RequestLine("PUT /v1/apiEndpoints/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
APIEndpoint restore1(RestoreEntity restoreEntity);
/**
* Restore a soft deleted APIEndpoint
* Similar to restore1 but it also returns the http response headers .
* Restore a soft deleted APIEndpoint.
* @param restoreEntity (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/apiEndpoints/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse restore1WithHttpInfo(RestoreEntity restoreEntity);
/**
* Update Vote for a APIEndpoint
* Update vote for a APIEndpoint
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return ChangeEvent
*/
@RequestLine("PUT /v1/apiEndpoints/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ChangeEvent updateVoteForAPIEndpoint(@Param("id") UUID id, VoteRequest voteRequest);
/**
* Update Vote for a APIEndpoint
* Similar to updateVoteForAPIEndpoint but it also returns the http response headers .
* Update vote for a APIEndpoint
* @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/apiEndpoints/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse updateVoteForAPIEndpointWithHttpInfo(@Param("id") UUID id, VoteRequest voteRequest);
}