IOrganizationResource (apiman-manager-api-rest 1.1.2.Final API)

@Path(value="organizations")
public interface IOrganizationResource

The Organization API.

Author:: eric.wittmann@redhat.com

Method Summary

Methods
Modifier and Type	Method and Description
`io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean>`	`activity(String organizationId, int page, int pageSize)` Returns audit activity information for a single Organization.
`io.apiman.manager.api.beans.orgs.OrganizationBean`	`create(io.apiman.manager.api.beans.orgs.NewOrganizationBean bean)` Use this endpoint to create a new Organization.
`io.apiman.manager.api.beans.apps.ApplicationBean`	`createApp(String organizationId, io.apiman.manager.api.beans.apps.NewApplicationBean bean)` Use this endpoint to create a new Application.
`io.apiman.manager.api.beans.policies.PolicyBean`	`createAppPolicy(String organizationId, String applicationId, String version, io.apiman.manager.api.beans.policies.NewPolicyBean bean)` Use this endpoint to add a new Policy to the Application version.
`io.apiman.manager.api.beans.apps.ApplicationVersionBean`	`createAppVersion(String organizationId, String applicationId, io.apiman.manager.api.beans.apps.NewApplicationVersionBean bean)` Use this endpoint to create a new version of the Application.
`io.apiman.manager.api.beans.contracts.ContractBean`	`createContract(String organizationId, String applicationId, String version, io.apiman.manager.api.beans.contracts.NewContractBean bean)` Use this endpoint to create a Contract between the Application and a Service.
`io.apiman.manager.api.beans.plans.PlanBean`	`createPlan(String organizationId, io.apiman.manager.api.beans.plans.NewPlanBean bean)` Use this endpoint to create a new Plan.
`io.apiman.manager.api.beans.policies.PolicyBean`	`createPlanPolicy(String organizationId, String planId, String version, io.apiman.manager.api.beans.policies.NewPolicyBean bean)` Use this endpoint to add a new Policy to the Plan version.
`io.apiman.manager.api.beans.plans.PlanVersionBean`	`createPlanVersion(String organizationId, String planId, io.apiman.manager.api.beans.plans.NewPlanVersionBean bean)` Use this endpoint to create a new version of the Plan.
`io.apiman.manager.api.beans.services.ServiceBean`	`createService(String organizationId, io.apiman.manager.api.beans.services.NewServiceBean bean)` Use this endpoint to create a new Service.
`io.apiman.manager.api.beans.policies.PolicyBean`	`createServicePolicy(String organizationId, String serviceId, String version, io.apiman.manager.api.beans.policies.NewPolicyBean bean)` Use this endpoint to add a new Policy to the Service version.
`io.apiman.manager.api.beans.services.ServiceVersionBean`	`createServiceVersion(String organizationId, String serviceId, io.apiman.manager.api.beans.services.NewServiceVersionBean bean)` Use this endpoint to create a new version of the Service.
`void`	`deleteAllContracts(String organizationId, String applicationId, String version)` Use this endpoint to break all contracts between this application and its services.
`void`	`deleteAppPolicy(String organizationId, String applicationId, String version, long policyId)` Use this endpoint to remove a Policy from the Application.
`void`	`deleteContract(String organizationId, String applicationId, String version, Long contractId)` Use this endpoint to break a Contract with a Service.
`void`	`deletePlanPolicy(String organizationId, String planId, String version, long policyId)` Use this endpoint to remove a Policy from the Plan.
`void`	`deleteServiceDefinition(String organizationId, String serviceId, String version)` Use this endpoint to delete a Service's definition document.
`void`	`deleteServicePolicy(String organizationId, String serviceId, String version, long policyId)` Use this endpoint to remove a Policy from the Service.
`io.apiman.manager.api.beans.orgs.OrganizationBean`	`get(String organizationId)` Use this endpoint to get information about a single Organization by its ID.
`io.apiman.manager.api.beans.summary.ApiRegistryBean`	`getApiRegistryJSON(String organizationId, String applicationId, String version)` Use this endpoint to get registry style information about all Services that this Application consumes.
`io.apiman.manager.api.beans.summary.ApiRegistryBean`	`getApiRegistryXML(String organizationId, String applicationId, String version)` Use this endpoint to get registry style information about all Services that this Application consumes.
`io.apiman.manager.api.beans.apps.ApplicationBean`	`getApp(String organizationId, String applicationId)` Use this endpoint to retrieve information about a single Application by ID.
`io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean>`	`getAppActivity(String organizationId, String applicationId, int page, int pageSize)` This endpoint returns audit activity information about the Application.
`List<io.apiman.manager.api.beans.summary.ContractSummaryBean>`	`getApplicationVersionContracts(String organizationId, String applicationId, String version)` Use this endpoint to get a list of all Contracts for an Application.
`io.apiman.manager.api.beans.policies.PolicyBean`	`getAppPolicy(String organizationId, String applicationId, String version, long policyId)` Use this endpoint to get information about a single Policy in the Application version.
`io.apiman.manager.api.beans.apps.ApplicationVersionBean`	`getAppVersion(String organizationId, String applicationId, String version)` Use this endpoint to get detailed information about a single version of an Application.
`io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean>`	`getAppVersionActivity(String organizationId, String applicationId, String version, int page, int pageSize)` Use this endpoint to get audit activity information for a single version of the Application.
`io.apiman.manager.api.beans.contracts.ContractBean`	`getContract(String organizationId, String applicationId, String version, Long contractId)` Use this endpoint to retrieve detailed information about a single Service Contract for an Application.
`io.apiman.manager.api.beans.plans.PlanBean`	`getPlan(String organizationId, String planId)` Use this endpoint to retrieve information about a single Plan by ID.
`io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean>`	`getPlanActivity(String organizationId, String planId, int page, int pageSize)` This endpoint returns audit activity information about the Plan.
`io.apiman.manager.api.beans.policies.PolicyBean`	`getPlanPolicy(String organizationId, String planId, String version, long policyId)` Use this endpoint to get information about a single Policy in the Plan version.
`io.apiman.manager.api.beans.plans.PlanVersionBean`	`getPlanVersion(String organizationId, String planId, String version)` Use this endpoint to get detailed information about a single version of a Plan.
`io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean>`	`getPlanVersionActivity(String organizationId, String planId, String version, int page, int pageSize)` Use this endpoint to get audit activity information for a single version of the Plan.
`io.apiman.manager.api.beans.services.ServiceBean`	`getService(String organizationId, String serviceId)` Use this endpoint to retrieve information about a single Service by ID.
`io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean>`	`getServiceActivity(String organizationId, String serviceId, int page, int pageSize)` This endpoint returns audit activity information about the Service.
`javax.ws.rs.core.Response`	`getServiceDefinition(String organizationId, String serviceId, String version)` Use this endpoint to retrieve the Service's definition document.
`io.apiman.manager.api.beans.policies.PolicyBean`	`getServicePolicy(String organizationId, String serviceId, String version, long policyId)` Use this endpoint to get information about a single Policy in the Service version.
`io.apiman.manager.api.beans.policies.PolicyChainBean`	`getServicePolicyChain(String organizationId, String serviceId, String version, String planId)` Use this endpoint to get a Policy Chain for the specific Service version.
`io.apiman.manager.api.beans.services.ServiceVersionBean`	`getServiceVersion(String organizationId, String serviceId, String version)` Use this endpoint to get detailed information about a single version of a Service.
`io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean>`	`getServiceVersionActivity(String organizationId, String serviceId, String version, int page, int pageSize)` Use this endpoint to get audit activity information for a single version of the Service.
`List<io.apiman.manager.api.beans.summary.ContractSummaryBean>`	`getServiceVersionContracts(String organizationId, String serviceId, String version, int page, int pageSize)` Use this endpoint to get a list of all Contracts created with this Service.
`io.apiman.manager.api.beans.summary.ServiceVersionEndpointSummaryBean`	`getServiceVersionEndpointInfo(String organizationId, String serviceId, String version)` Use this endpoint to get information about the Managed Service's gateway endpoint.
`List<io.apiman.manager.api.beans.summary.ServicePlanSummaryBean>`	`getServiceVersionPlans(String organizationId, String serviceId, String version)` Use this endpoint to list the Plans configured for the given Service version.
`void`	`grant(String organizationId, io.apiman.manager.api.beans.idm.GrantRolesBean bean)` Grant membership in a role to a user.
`List<io.apiman.manager.api.beans.summary.PolicySummaryBean>`	`listAppPolicies(String organizationId, String applicationId, String version)` Use this endpoint to list all of the Policies configured for the Application.
`List<io.apiman.manager.api.beans.summary.ApplicationSummaryBean>`	`listApps(String organizationId)` Use this endpoint to get a list of all Applications in the Organization.
`List<io.apiman.manager.api.beans.summary.ApplicationVersionSummaryBean>`	`listAppVersions(String organizationId, String applicationId)` Use this endpoint to list all of the versions of an Application.
`List<io.apiman.manager.api.beans.members.MemberBean>`	`listMembers(String organizationId)` Lists all members of the organization.
`List<io.apiman.manager.api.beans.summary.PolicySummaryBean>`	`listPlanPolicies(String organizationId, String planId, String version)` Use this endpoint to list all of the Policies configured for the Plan.
`List<io.apiman.manager.api.beans.summary.PlanSummaryBean>`	`listPlans(String organizationId)` Use this endpoint to get a list of all Plans in the Organization.
`List<io.apiman.manager.api.beans.summary.PlanVersionSummaryBean>`	`listPlanVersions(String organizationId, String planId)` Use this endpoint to list all of the versions of a Plan.
`List<io.apiman.manager.api.beans.summary.PolicySummaryBean>`	`listServicePolicies(String organizationId, String serviceId, String version)` Use this endpoint to list all of the Policies configured for the Service.
`List<io.apiman.manager.api.beans.summary.ServiceSummaryBean>`	`listServices(String organizationId)` Use this endpoint to get a list of all Services in the Organization.
`List<io.apiman.manager.api.beans.summary.ServiceVersionSummaryBean>`	`listServiceVersions(String organizationId, String serviceId)` Use this endpoint to list all of the versions of a Service.
`void`	`reorderApplicationPolicies(String organizationId, String applicationId, String version, io.apiman.manager.api.beans.policies.PolicyChainBean policyChain)` Use this endpoint to change the order of Policies for an Application.
`void`	`reorderPlanPolicies(String organizationId, String planId, String version, io.apiman.manager.api.beans.policies.PolicyChainBean policyChain)` Use this endpoint to change the order of Policies for a Plan.
`void`	`reorderServicePolicies(String organizationId, String serviceId, String version, io.apiman.manager.api.beans.policies.PolicyChainBean policyChain)` Use this endpoint to change the order of Policies for a Service.
`void`	`revoke(String organizationId, String roleId, String userId)` Revoke membership in a role.
`void`	`revokeAll(String organizationId, String userId)` Revoke all of a user's role memberships from the org.
`void`	`update(String organizationId, io.apiman.manager.api.beans.orgs.UpdateOrganizationBean bean)` Updates meta-information about a single Organization.
`void`	`updateApp(String organizationId, String applicationId, io.apiman.manager.api.beans.apps.UpdateApplicationBean bean)` Use this endpoint to update information about an Application.
`void`	`updateAppPolicy(String organizationId, String applicationId, String version, long policyId, io.apiman.manager.api.beans.policies.UpdatePolicyBean bean)` Use this endpoint to update the meta-data or configuration of a single Application Policy.
`void`	`updatePlan(String organizationId, String planId, io.apiman.manager.api.beans.plans.UpdatePlanBean bean)` Use this endpoint to update information about a Plan.
`void`	`updatePlanPolicy(String organizationId, String planId, String version, long policyId, io.apiman.manager.api.beans.policies.UpdatePolicyBean bean)` Use this endpoint to update the meta-data or configuration of a single Plan Policy.
`void`	`updateService(String organizationId, String serviceId, io.apiman.manager.api.beans.services.UpdateServiceBean bean)` Use this endpoint to update information about a Service.
`void`	`updateServiceDefinition(String organizationId, String serviceId, String version)` Use this endpoint to update the Service's definition document.
`void`	`updateServicePolicy(String organizationId, String serviceId, String version, long policyId, io.apiman.manager.api.beans.policies.UpdatePolicyBean bean)` Use this endpoint to update the meta-data or configuration of a single Service Policy.
`io.apiman.manager.api.beans.services.ServiceVersionBean`	`updateServiceVersion(String organizationId, String serviceId, String version, io.apiman.manager.api.beans.services.UpdateServiceVersionBean bean)` Use this endpoint to update information about a single version of a Service.

Method Detail

create

@POST
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.orgs.OrganizationBean create(io.apiman.manager.api.beans.orgs.NewOrganizationBean bean)
                                                         throws OrganizationAlreadyExistsException,
                                                                NotAuthorizedException

Use this endpoint to create a new Organization.

Parameters:: bean - Information about the new Organization.
Returns:: Full details about the Organization that was created.
Throws:: OrganizationAlreadyExistsException - when trying to create an Organization that already exists; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

get

@GET
@Path(value="{organizationId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.orgs.OrganizationBean get(@PathParam(value="organizationId")
                                                                      String organizationId)
                                                      throws OrganizationNotFoundException,
                                                             NotAuthorizedException

Use this endpoint to get information about a single Organization by its ID.

Parameters:: organizationId - The Organization id.
Returns:: The Organization.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

update

@PUT
@Path(value="{organizationId}")
@Consumes(value="application/json")
void update(@PathParam(value="organizationId")
                            String organizationId,
                            io.apiman.manager.api.beans.orgs.UpdateOrganizationBean bean)
            throws OrganizationNotFoundException,
                   NotAuthorizedException

Updates meta-information about a single Organization.

Parameters:: organizationId - The Organization ID.; bean - Updated Organization information.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

activity

@GET
@Path(value="{organizationId}/activity")
@Produces(value="application/json")
io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean> activity(@PathParam(value="organizationId")
                                                                                                                                String organizationId,
                                                                                                                                @QueryParam(value="page")
                                                                                                                                int page,
                                                                                                                                @QueryParam(value="count")
                                                                                                                                int pageSize)
                                                                                                                throws OrganizationNotFoundException,
                                                                                                                       NotAuthorizedException

Returns audit activity information for a single Organization. The audit information that is returned represents all of the activity associated with this Organization (i.e. an audit log for everything in the Organization).

Parameters:: organizationId - The Organization ID.; page - Which page of activity results to return.; pageSize - The number of entries per page.
Returns:: List of audit/activity entries.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createApp

@POST
@Path(value="{organizationId}/applications")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.apps.ApplicationBean createApp(@PathParam(value="organizationId")
                                                                                     String organizationId,
                                                                                     io.apiman.manager.api.beans.apps.NewApplicationBean bean)
                                                           throws OrganizationNotFoundException,
                                                                  ApplicationAlreadyExistsException,
                                                                  NotAuthorizedException

Use this endpoint to create a new Application. Note that it is important to also create an initial version of the Application (e.g. 1.0). This can either be done by including the 'initialVersion' property in the request, or by immediately following up with a call to "Create Application Version". If the former is done, then a first Application version will be created automatically by this endpoint.

Parameters:: organizationId - The Organization ID.; bean - Information about the new Application.
Returns:: Full details about the newly created Application.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationAlreadyExistsException - when trying to create an Application that already exists; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getApp

@GET
@Path(value="{organizationId}/applications/{applicationId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.apps.ApplicationBean getApp(@PathParam(value="organizationId")
                                                                        String organizationId,
                                                                        @PathParam(value="applicationId")
                                                                        String applicationId)
                                                        throws ApplicationNotFoundException,
                                                               NotAuthorizedException

Use this endpoint to retrieve information about a single Application by ID. Note that this only returns information about the Application, not about any particular *version* of the Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.
Returns:: An Application.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist when trying to get, update, or delete an application that does not exist.; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getAppActivity

@GET
@Path(value="{organizationId}/applications/{applicationId}/activity")
@Produces(value="application/json")
io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean> getAppActivity(@PathParam(value="organizationId")
                                                                                                                                      String organizationId,
                                                                                                                                      @PathParam(value="applicationId")
                                                                                                                                      String applicationId,
                                                                                                                                      @QueryParam(value="page")
                                                                                                                                      int page,
                                                                                                                                      @QueryParam(value="count")
                                                                                                                                      int pageSize)
                                                                                                                      throws ApplicationNotFoundException,
                                                                                                                             NotAuthorizedException

This endpoint returns audit activity information about the Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; page - Which page of activity should be returned.; pageSize - The number of entries per page to return.
Returns:: A list of audit activity entries.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listApps

@GET
@Path(value="{organizationId}/applications")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.ApplicationSummaryBean> listApps(@PathParam(value="organizationId")
                                                                                          String organizationId)
                                                                          throws OrganizationNotFoundException,
                                                                                 NotAuthorizedException

Use this endpoint to get a list of all Applications in the Organization.

Parameters:: organizationId - The Organization ID.
Returns:: A list of Applications.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

updateApp

@PUT
@Path(value="{organizationId}/applications/{applicationId}")
@Consumes(value="application/json")
@Produces(value="application/json")
void updateApp(@PathParam(value="organizationId")
                                        String organizationId,
                                        @PathParam(value="applicationId")
                                        String applicationId,
                                        io.apiman.manager.api.beans.apps.UpdateApplicationBean bean)
               throws ApplicationNotFoundException,
                      NotAuthorizedException

Use this endpoint to update information about an Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; bean - Updated Application information.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createAppVersion

@POST
@Path(value="{organizationId}/applications/{applicationId}/versions")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.apps.ApplicationVersionBean createAppVersion(@PathParam(value="organizationId")
                                                                                                   String organizationId,
                                                                                                   @PathParam(value="applicationId")
                                                                                                   String applicationId,
                                                                                                   io.apiman.manager.api.beans.apps.NewApplicationVersionBean bean)
                                                                         throws ApplicationNotFoundException,
                                                                                NotAuthorizedException

Use this endpoint to create a new version of the Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; bean - Initial information about the new Application version.
Returns:: Full details about the newly created Application version.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listAppVersions

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.ApplicationVersionSummaryBean> listAppVersions(@PathParam(value="organizationId")
                                                                                                        String organizationId,
                                                                                                        @PathParam(value="applicationId")
                                                                                                        String applicationId)
                                                                                        throws ApplicationNotFoundException,
                                                                                               NotAuthorizedException

Use this endpoint to list all of the versions of an Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.
Returns:: A list of Applications.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getAppVersion

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}")
@Produces(value="application/json")
io.apiman.manager.api.beans.apps.ApplicationVersionBean getAppVersion(@PathParam(value="organizationId")
                                                                                      String organizationId,
                                                                                      @PathParam(value="applicationId")
                                                                                      String applicationId,
                                                                                      @PathParam(value="version")
                                                                                      String version)
                                                                      throws ApplicationVersionNotFoundException,
                                                                             NotAuthorizedException

Use this endpoint to get detailed information about a single version of an Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.
Returns:: An Application version.
Throws:: ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getAppVersionActivity

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/activity")
@Produces(value="application/json")
io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean> getAppVersionActivity(@PathParam(value="organizationId")
                                                                                                                                             String organizationId,
                                                                                                                                             @PathParam(value="applicationId")
                                                                                                                                             String applicationId,
                                                                                                                                             @PathParam(value="version")
                                                                                                                                             String version,
                                                                                                                                             @QueryParam(value="page")
                                                                                                                                             int page,
                                                                                                                                             @QueryParam(value="count")
                                                                                                                                             int pageSize)
                                                                                                                             throws ApplicationVersionNotFoundException,
                                                                                                                                    NotAuthorizedException

Use this endpoint to get audit activity information for a single version of the Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; page - Which page of activity data to return.; pageSize - The number of entries per page to return.
Returns:: A list of audit entries.
Throws:: ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createContract

@POST
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/contracts")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.contracts.ContractBean createContract(@PathParam(value="organizationId")
                                                                                            String organizationId,
                                                                                            @PathParam(value="applicationId")
                                                                                            String applicationId,
                                                                                            @PathParam(value="version")
                                                                                            String version,
                                                                                            io.apiman.manager.api.beans.contracts.NewContractBean bean)
                                                                  throws OrganizationNotFoundException,
                                                                         ApplicationNotFoundException,
                                                                         ServiceNotFoundException,
                                                                         PlanNotFoundException,
                                                                         ContractAlreadyExistsException,
                                                                         NotAuthorizedException

Use this endpoint to create a Contract between the Application and a Service. In order to create a Contract, the caller must specify the Organization, ID, and Version of the Service. Additionally the caller must specify the ID of the Plan it wished to use for the Contract with the Service.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; bean - Required information about the new Contract.
Returns:: Full details about the newly created Contract.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; ServiceNotFoundException - when trying to get, update, or delete an service that does not exist when trying to get, update, or delete an plan that does not exist; PlanNotFoundException - when trying to get, update, or delete an plan that does not exist; ContractAlreadyExistsException - when trying to create an Contract that already exists; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getContract

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/contracts/{contractId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.contracts.ContractBean getContract(@PathParam(value="organizationId")
                                                                               String organizationId,
                                                                               @PathParam(value="applicationId")
                                                                               String applicationId,
                                                                               @PathParam(value="version")
                                                                               String version,
                                                                               @PathParam(value="contractId")
                                                                               Long contractId)
                                                               throws ApplicationNotFoundException,
                                                                      ContractNotFoundException,
                                                                      NotAuthorizedException

Use this endpoint to retrieve detailed information about a single Service Contract for an Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; contractId - The ID of the Contract.
Returns:: Details about a single Contract.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; ContractNotFoundException - when trying to get, update, or delete a contract that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getApplicationVersionContracts

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/contracts")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.ContractSummaryBean> getApplicationVersionContracts(@PathParam(value="organizationId")
                                                                                                             String organizationId,
                                                                                                             @PathParam(value="applicationId")
                                                                                                             String applicationId,
                                                                                                             @PathParam(value="version")
                                                                                                             String version)
                                                                                             throws ApplicationNotFoundException,
                                                                                                    NotAuthorizedException

Use this endpoint to get a list of all Contracts for an Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.
Returns:: A list of Contracts.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getApiRegistryJSON

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/apiregistry/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.summary.ApiRegistryBean getApiRegistryJSON(@PathParam(value="organizationId")
                                                                                       String organizationId,
                                                                                       @PathParam(value="applicationId")
                                                                                       String applicationId,
                                                                                       @PathParam(value="version")
                                                                                       String version)
                                                                       throws ApplicationNotFoundException,
                                                                              NotAuthorizedException

Use this endpoint to get registry style information about all Services that this Application consumes. This is a useful endpoint to invoke in order to retrieve a summary of every Service consumed by the application. The information returned by this endpoint could potentially be included directly in a client application as a way to lookup endpoint information for the APIs it wishes to consume. This variant of the API Registry is formatted as JSON data.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.
Returns:: API Registry information.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getApiRegistryXML

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/apiregistry/xml")
@Produces(value="application/xml")
io.apiman.manager.api.beans.summary.ApiRegistryBean getApiRegistryXML(@PathParam(value="organizationId")
                                                                                      String organizationId,
                                                                                      @PathParam(value="applicationId")
                                                                                      String applicationId,
                                                                                      @PathParam(value="version")
                                                                                      String version)
                                                                      throws ApplicationNotFoundException,
                                                                             NotAuthorizedException

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.
Returns:: API Registry information.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

deleteAllContracts

@DELETE
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/contracts")
void deleteAllContracts(@PathParam(value="organizationId")
                                  String organizationId,
                                  @PathParam(value="applicationId")
                                  String applicationId,
                                  @PathParam(value="version")
                                  String version)
                        throws ApplicationNotFoundException,
                               NotAuthorizedException

Use this endpoint to break all contracts between this application and its services.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

deleteContract

@DELETE
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/contracts/{contractId}")
void deleteContract(@PathParam(value="organizationId")
                              String organizationId,
                              @PathParam(value="applicationId")
                              String applicationId,
                              @PathParam(value="version")
                              String version,
                              @PathParam(value="contractId")
                              Long contractId)
                    throws ApplicationNotFoundException,
                           ContractNotFoundException,
                           NotAuthorizedException

Use this endpoint to break a Contract with a Service.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; contractId - The Contract ID.
Throws:: ApplicationNotFoundException - when trying to get, update, or delete an application that does not exist; ContractNotFoundException - when trying to get, update, or delete a contract that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createAppPolicy

@POST
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/policies")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.policies.PolicyBean createAppPolicy(@PathParam(value="organizationId")
                                                                                          String organizationId,
                                                                                          @PathParam(value="applicationId")
                                                                                          String applicationId,
                                                                                          @PathParam(value="version")
                                                                                          String version,
                                                                                          io.apiman.manager.api.beans.policies.NewPolicyBean bean)
                                                                throws OrganizationNotFoundException,
                                                                       ApplicationVersionNotFoundException,
                                                                       NotAuthorizedException

Use this endpoint to add a new Policy to the Application version.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; bean - Information about the new Policy.
Returns:: Full details about the newly added Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getAppPolicy

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/policies/{policyId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.policies.PolicyBean getAppPolicy(@PathParam(value="organizationId")
                                                                             String organizationId,
                                                                             @PathParam(value="applicationId")
                                                                             String applicationId,
                                                                             @PathParam(value="version")
                                                                             String version,
                                                                             @PathParam(value="policyId")
                                                                             long policyId)
                                                             throws OrganizationNotFoundException,
                                                                    ApplicationVersionNotFoundException,
                                                                    PolicyNotFoundException,
                                                                    NotAuthorizedException

Use this endpoint to get information about a single Policy in the Application version.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; policyId - The Policy ID.
Returns:: Full information about the Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

updateAppPolicy

@PUT
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/policies/{policyId}")
@Consumes(value="application/json")
@Produces(value="application/json")
void updateAppPolicy(@PathParam(value="organizationId")
                                              String organizationId,
                                              @PathParam(value="applicationId")
                                              String applicationId,
                                              @PathParam(value="version")
                                              String version,
                                              @PathParam(value="policyId")
                                              long policyId,
                                              io.apiman.manager.api.beans.policies.UpdatePolicyBean bean)
                     throws OrganizationNotFoundException,
                            ApplicationVersionNotFoundException,
                            PolicyNotFoundException,
                            NotAuthorizedException

Use this endpoint to update the meta-data or configuration of a single Application Policy.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; policyId - The Policy ID.; bean - New meta-data and/or configuration for the Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

deleteAppPolicy

@DELETE
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/policies/{policyId}")
void deleteAppPolicy(@PathParam(value="organizationId")
                               String organizationId,
                               @PathParam(value="applicationId")
                               String applicationId,
                               @PathParam(value="version")
                               String version,
                               @PathParam(value="policyId")
                               long policyId)
                     throws OrganizationNotFoundException,
                            ApplicationVersionNotFoundException,
                            PolicyNotFoundException,
                            NotAuthorizedException

Use this endpoint to remove a Policy from the Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; policyId - The Policy ID.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listAppPolicies

@GET
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/policies")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.PolicySummaryBean> listAppPolicies(@PathParam(value="organizationId")
                                                                                            String organizationId,
                                                                                            @PathParam(value="applicationId")
                                                                                            String applicationId,
                                                                                            @PathParam(value="version")
                                                                                            String version)
                                                                            throws OrganizationNotFoundException,
                                                                                   ApplicationVersionNotFoundException,
                                                                                   NotAuthorizedException

Use this endpoint to list all of the Policies configured for the Application.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.
Returns:: A List of Policies.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

reorderApplicationPolicies

@POST
@Path(value="{organizationId}/applications/{applicationId}/versions/{version}/reorderPolicies")
@Consumes(value="application/json")
void reorderApplicationPolicies(@PathParam(value="organizationId")
                                                 String organizationId,
                                                 @PathParam(value="applicationId")
                                                 String applicationId,
                                                 @PathParam(value="version")
                                                 String version,
                                                 io.apiman.manager.api.beans.policies.PolicyChainBean policyChain)
                                throws OrganizationNotFoundException,
                                       ApplicationVersionNotFoundException,
                                       NotAuthorizedException

Use this endpoint to change the order of Policies for an Application. When a Policy is added to the Application, it is added as the last Policy in the list of Application Policies. Sometimes the order of Policies is important, so it is often useful to re-order the Policies by invoking this endpoint. The body of the request should include all of the Policies for the Application, in the new desired order. Note that only the IDs of each of the Policies is actually required in the request, at a minimum.

Parameters:: organizationId - The Organization ID.; applicationId - The Application ID.; version - The Application version.; policyChain - The Policies in the desired order.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ApplicationVersionNotFoundException - when trying to get, update, or delete a application version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createService

@POST
@Path(value="{organizationId}/services")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.services.ServiceBean createService(@PathParam(value="organizationId")
                                                                                         String organizationId,
                                                                                         io.apiman.manager.api.beans.services.NewServiceBean bean)
                                                               throws OrganizationNotFoundException,
                                                                      ServiceAlreadyExistsException,
                                                                      NotAuthorizedException

Use this endpoint to create a new Service. Note that it is important to also create an initial version of the Service (e.g. 1.0). This can either be done by including the 'initialVersion' property in the request, or by immediately following up with a call to "Create Service Version". If the former is done, then a first Service version will be created automatically by this endpoint.

Parameters:: organizationId - The Organization ID.; bean - Information about the new Service.
Returns:: Full details about the newly created Service.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceAlreadyExistsException - when trying to create an Service that already exists; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getService

@GET
@Path(value="{organizationId}/services/{serviceId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.services.ServiceBean getService(@PathParam(value="organizationId")
                                                                            String organizationId,
                                                                            @PathParam(value="serviceId")
                                                                            String serviceId)
                                                            throws ServiceNotFoundException,
                                                                   NotAuthorizedException

Use this endpoint to retrieve information about a single Service by ID. Note that this only returns information about the Service, not about any particular *version* of the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.
Returns:: A Service.
Throws:: ServiceNotFoundException - when trying to get, update, or delete an service that does not exist when trying to get, update, or delete an service that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listServices

@GET
@Path(value="{organizationId}/services")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.ServiceSummaryBean> listServices(@PathParam(value="organizationId")
                                                                                          String organizationId)
                                                                          throws OrganizationNotFoundException,
                                                                                 NotAuthorizedException

Use this endpoint to get a list of all Services in the Organization.

Parameters:: organizationId - The Organization ID.
Returns:: A list of Services.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

updateService

@PUT
@Path(value="{organizationId}/services/{serviceId}")
@Consumes(value="application/json")
@Produces(value="application/json")
void updateService(@PathParam(value="organizationId")
                                            String organizationId,
                                            @PathParam(value="serviceId")
                                            String serviceId,
                                            io.apiman.manager.api.beans.services.UpdateServiceBean bean)
                   throws ServiceNotFoundException,
                          NotAuthorizedException

Use this endpoint to update information about a Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; bean - Updated Service information.
Throws:: ServiceNotFoundException - when trying to get, update, or delete an service that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServiceActivity

@GET
@Path(value="{organizationId}/services/{serviceId}/activity")
@Produces(value="application/json")
io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean> getServiceActivity(@PathParam(value="organizationId")
                                                                                                                                          String organizationId,
                                                                                                                                          @PathParam(value="serviceId")
                                                                                                                                          String serviceId,
                                                                                                                                          @QueryParam(value="page")
                                                                                                                                          int page,
                                                                                                                                          @QueryParam(value="count")
                                                                                                                                          int pageSize)
                                                                                                                          throws ServiceNotFoundException,
                                                                                                                                 NotAuthorizedException

This endpoint returns audit activity information about the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; page - Which page of activity should be returned.; pageSize - The number of entries per page to return.
Returns:: A list of audit activity entries.
Throws:: ServiceNotFoundException - when trying to get, update, or delete an service that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createServiceVersion

@POST
@Path(value="{organizationId}/services/{serviceId}/versions")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.services.ServiceVersionBean createServiceVersion(@PathParam(value="organizationId")
                                                                                                       String organizationId,
                                                                                                       @PathParam(value="serviceId")
                                                                                                       String serviceId,
                                                                                                       io.apiman.manager.api.beans.services.NewServiceVersionBean bean)
                                                                             throws ServiceNotFoundException,
                                                                                    NotAuthorizedException

Use this endpoint to create a new version of the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; bean - Initial information about the new Service version.
Returns:: Full details about the newly created Service version.
Throws:: ServiceNotFoundException - when trying to get, update, or delete an service that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listServiceVersions

@GET
@Path(value="{organizationId}/services/{serviceId}/versions")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.ServiceVersionSummaryBean> listServiceVersions(@PathParam(value="organizationId")
                                                                                                        String organizationId,
                                                                                                        @PathParam(value="serviceId")
                                                                                                        String serviceId)
                                                                                        throws ServiceNotFoundException,
                                                                                               NotAuthorizedException

Use this endpoint to list all of the versions of a Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.
Returns:: A list of Services.
Throws:: ServiceNotFoundException - when trying to get, update, or delete an service that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServiceVersion

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}")
@Produces(value="application/json")
io.apiman.manager.api.beans.services.ServiceVersionBean getServiceVersion(@PathParam(value="organizationId")
                                                                                          String organizationId,
                                                                                          @PathParam(value="serviceId")
                                                                                          String serviceId,
                                                                                          @PathParam(value="version")
                                                                                          String version)
                                                                          throws ServiceVersionNotFoundException,
                                                                                 NotAuthorizedException

Use this endpoint to get detailed information about a single version of a Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.
Returns:: A Service version.
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServiceDefinition

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/definition")
@Produces(value={"application/json","application/wsdl+xml","application/x-yaml"})
javax.ws.rs.core.Response getServiceDefinition(@PathParam(value="organizationId")
                                                               String organizationId,
                                                               @PathParam(value="serviceId")
                                                               String serviceId,
                                                               @PathParam(value="version")
                                                               String version)
                                               throws ServiceVersionNotFoundException,
                                                      NotAuthorizedException

Use this endpoint to retrieve the Service's definition document. A service definition document can be several different types, depending on the Service type and technology used to define the service. For example, this endpoint might return a WSDL document, or a Swagger JSON document.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.
Returns:: The Service Definition document (e.g. a Swagger JSON file).
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServiceVersionEndpointInfo

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/endpoint")
@Produces(value="application/json")
io.apiman.manager.api.beans.summary.ServiceVersionEndpointSummaryBean getServiceVersionEndpointInfo(@PathParam(value="organizationId")
                                                                                                                    String organizationId,
                                                                                                                    @PathParam(value="serviceId")
                                                                                                                    String serviceId,
                                                                                                                    @PathParam(value="version")
                                                                                                                    String version)
                                                                                                    throws ServiceVersionNotFoundException,
                                                                                                           InvalidServiceStatusException,
                                                                                                           GatewayNotFoundException

Use this endpoint to get information about the Managed Service's gateway endpoint. In other words, this returns the actual live endpoint on the API Gateway - the endpoint that a client should use when invoking the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.
Returns:: The live Service endpoint information.
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; InvalidServiceStatusException - when the user attempts some action on the service when it is not in an appropriate state/status; GatewayNotFoundException - when trying to get, update, or delete a gateay that does not exist

updateServiceVersion

@PUT
@Path(value="{organizationId}/services/{serviceId}/versions/{version}")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.services.ServiceVersionBean updateServiceVersion(@PathParam(value="organizationId")
                                                                                                      String organizationId,
                                                                                                      @PathParam(value="serviceId")
                                                                                                      String serviceId,
                                                                                                      @PathParam(value="version")
                                                                                                      String version,
                                                                                                      io.apiman.manager.api.beans.services.UpdateServiceVersionBean bean)
                                                                             throws ServiceVersionNotFoundException,
                                                                                    NotAuthorizedException,
                                                                                    InvalidServiceStatusException

Use this endpoint to update information about a single version of a Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; bean - Updated information about the Service version.
Returns:: The updated Service Version.
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to; InvalidServiceStatusException - when the user attempts some action on the service when it is not in an appropriate state/status

updateServiceDefinition
```
@PUT
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/definition")
@Consumes(value={"application/json","application/wsdl+xml","application/x-yaml"})
void updateServiceDefinition(@PathParam(value="organizationId")
                                             String organizationId,
                                             @PathParam(value="serviceId")
                                             String serviceId,
                                             @PathParam(value="version")
                                             String version)
                             throws ServiceVersionNotFoundException,
                                    NotAuthorizedException,
                                    InvalidServiceStatusException
```
Use this endpoint to update the Service's definition document. A service definition will vary depending on the type of service, and the type of definition used. For example, it might be a Swagger document or a WSDL file. To use this endpoint, simply PUT the updated Service Definition document in its entirety, making sure to set the Content-Type appropriately for the type of definition document. The content will be stored and the Service's "Definition Type" field will be updated.
Whenever a service's definition is updated, the "definitionType" property of that service is automatically set based on the request Content-Type. There is no other way to set the service's definition type property. The following is a map of Content-Type to service definition type.

Content Type Service Definition Type

application/json SwaggerJSON

application/x-yaml SwaggerYAML

application/wsdl+xml WSDL

Parameters:
organizationId - The Organization ID.
serviceId - The Service ID.
version - The Service version.

Throws:

ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist

NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

InvalidServiceStatusException - when the user attempts some action on the service when it is not in an appropriate state/status

Content Type	Service Definition Type
application/json	SwaggerJSON
application/x-yaml	SwaggerYAML
application/wsdl+xml	WSDL

getServiceVersionActivity

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/activity")
@Produces(value="application/json")
io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean> getServiceVersionActivity(@PathParam(value="organizationId")
                                                                                                                                                 String organizationId,
                                                                                                                                                 @PathParam(value="serviceId")
                                                                                                                                                 String serviceId,
                                                                                                                                                 @PathParam(value="version")
                                                                                                                                                 String version,
                                                                                                                                                 @QueryParam(value="page")
                                                                                                                                                 int page,
                                                                                                                                                 @QueryParam(value="count")
                                                                                                                                                 int pageSize)
                                                                                                                                 throws ServiceVersionNotFoundException,
                                                                                                                                        NotAuthorizedException

Use this endpoint to get audit activity information for a single version of the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; page - Which page of activity data to return.; pageSize - The number of entries per page to return.
Returns:: A list of audit entries.
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServiceVersionPlans

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/plans")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.ServicePlanSummaryBean> getServiceVersionPlans(@PathParam(value="organizationId")
                                                                                                        String organizationId,
                                                                                                        @PathParam(value="serviceId")
                                                                                                        String serviceId,
                                                                                                        @PathParam(value="version")
                                                                                                        String version)
                                                                                        throws ServiceVersionNotFoundException,
                                                                                               NotAuthorizedException

Use this endpoint to list the Plans configured for the given Service version.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.
Returns:: A list of Service plans.
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createServicePolicy

@POST
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/policies")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.policies.PolicyBean createServicePolicy(@PathParam(value="organizationId")
                                                                                              String organizationId,
                                                                                              @PathParam(value="serviceId")
                                                                                              String serviceId,
                                                                                              @PathParam(value="version")
                                                                                              String version,
                                                                                              io.apiman.manager.api.beans.policies.NewPolicyBean bean)
                                                                    throws OrganizationNotFoundException,
                                                                           ServiceVersionNotFoundException,
                                                                           NotAuthorizedException

Use this endpoint to add a new Policy to the Service version.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; bean - Information about the new Policy.
Returns:: Full details about the newly added Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServicePolicy

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/policies/{policyId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.policies.PolicyBean getServicePolicy(@PathParam(value="organizationId")
                                                                                 String organizationId,
                                                                                 @PathParam(value="serviceId")
                                                                                 String serviceId,
                                                                                 @PathParam(value="version")
                                                                                 String version,
                                                                                 @PathParam(value="policyId")
                                                                                 long policyId)
                                                                 throws OrganizationNotFoundException,
                                                                        ServiceVersionNotFoundException,
                                                                        PolicyNotFoundException,
                                                                        NotAuthorizedException

Use this endpoint to get information about a single Policy in the Service version.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; policyId - The Policy ID.
Returns:: Full information about the Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

updateServicePolicy

@PUT
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/policies/{policyId}")
@Consumes(value="application/json")
@Produces(value="application/json")
void updateServicePolicy(@PathParam(value="organizationId")
                                                  String organizationId,
                                                  @PathParam(value="serviceId")
                                                  String serviceId,
                                                  @PathParam(value="version")
                                                  String version,
                                                  @PathParam(value="policyId")
                                                  long policyId,
                                                  io.apiman.manager.api.beans.policies.UpdatePolicyBean bean)
                         throws OrganizationNotFoundException,
                                ServiceVersionNotFoundException,
                                PolicyNotFoundException,
                                NotAuthorizedException

Use this endpoint to update the meta-data or configuration of a single Service Policy.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; policyId - The Policy ID.; bean - New meta-data and/or configuration for the Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

deleteServicePolicy

@DELETE
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/policies/{policyId}")
void deleteServicePolicy(@PathParam(value="organizationId")
                                   String organizationId,
                                   @PathParam(value="serviceId")
                                   String serviceId,
                                   @PathParam(value="version")
                                   String version,
                                   @PathParam(value="policyId")
                                   long policyId)
                         throws OrganizationNotFoundException,
                                ServiceVersionNotFoundException,
                                PolicyNotFoundException,
                                NotAuthorizedException

Use this endpoint to remove a Policy from the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; policyId - The Policy ID.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

deleteServiceDefinition

@DELETE
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/definition")
void deleteServiceDefinition(@PathParam(value="organizationId")
                                       String organizationId,
                                       @PathParam(value="serviceId")
                                       String serviceId,
                                       @PathParam(value="version")
                                       String version)
                             throws OrganizationNotFoundException,
                                    ServiceVersionNotFoundException,
                                    NotAuthorizedException

Use this endpoint to delete a Service's definition document. When this is done, the "definitionType" field on the Service will be set to None.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listServicePolicies

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/policies")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.PolicySummaryBean> listServicePolicies(@PathParam(value="organizationId")
                                                                                                String organizationId,
                                                                                                @PathParam(value="serviceId")
                                                                                                String serviceId,
                                                                                                @PathParam(value="version")
                                                                                                String version)
                                                                                throws OrganizationNotFoundException,
                                                                                       ServiceVersionNotFoundException,
                                                                                       NotAuthorizedException

Use this endpoint to list all of the Policies configured for the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.
Returns:: A List of Policies.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

reorderServicePolicies

@POST
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/reorderPolicies")
@Consumes(value="application/json")
void reorderServicePolicies(@PathParam(value="organizationId")
                                             String organizationId,
                                             @PathParam(value="serviceId")
                                             String serviceId,
                                             @PathParam(value="version")
                                             String version,
                                             io.apiman.manager.api.beans.policies.PolicyChainBean policyChain)
                            throws OrganizationNotFoundException,
                                   ServiceVersionNotFoundException,
                                   NotAuthorizedException

Use this endpoint to change the order of Policies for a Service. When a Policy is added to the Service, it is added as the last Policy in the list of Service Policies. Sometimes the order of Policies is important, so it is often useful to re-order the Policies by invoking this endpoint. The body of the request should include all of the Policies for the Service, in the new desired order. Note that only the IDs of each of the Policies is actually required in the request, at a minimum.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; policyChain - The Policies in the desired order.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServicePolicyChain

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/plans/{planId}/policyChain")
@Produces(value="application/json")
io.apiman.manager.api.beans.policies.PolicyChainBean getServicePolicyChain(@PathParam(value="organizationId")
                                                                                           String organizationId,
                                                                                           @PathParam(value="serviceId")
                                                                                           String serviceId,
                                                                                           @PathParam(value="version")
                                                                                           String version,
                                                                                           @PathParam(value="planId")
                                                                                           String planId)
                                                                           throws ServiceVersionNotFoundException,
                                                                                  NotAuthorizedException

Use this endpoint to get a Policy Chain for the specific Service version. A Policy Chain is a useful summary to better understand which Policies would be executed for a request to this Service through a particular Plan offered by the Service. Often this information is interesting prior to create a Contract with the Service.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; planId - The Plan ID.
Returns:: A Policy Chain.
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getServiceVersionContracts

@GET
@Path(value="{organizationId}/services/{serviceId}/versions/{version}/contracts")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.ContractSummaryBean> getServiceVersionContracts(@PathParam(value="organizationId")
                                                                                                         String organizationId,
                                                                                                         @PathParam(value="serviceId")
                                                                                                         String serviceId,
                                                                                                         @PathParam(value="version")
                                                                                                         String version,
                                                                                                         @QueryParam(value="page")
                                                                                                         int page,
                                                                                                         @QueryParam(value="count")
                                                                                                         int pageSize)
                                                                                         throws ServiceVersionNotFoundException,
                                                                                                NotAuthorizedException

Use this endpoint to get a list of all Contracts created with this Service. This will return Contracts created by between any Application and through any Plan.

Parameters:: organizationId - The Organization ID.; serviceId - The Service ID.; version - The Service version.; page - Which page of Contracts to return.; pageSize - The number of Contracts per page to return.
Returns:: A list of Contracts.
Throws:: ServiceVersionNotFoundException - when trying to get, update, or delete a service version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createPlan

@POST
@Path(value="{organizationId}/plans")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.plans.PlanBean createPlan(@PathParam(value="organizationId")
                                                                                String organizationId,
                                                                                io.apiman.manager.api.beans.plans.NewPlanBean bean)
                                                      throws OrganizationNotFoundException,
                                                             PlanAlreadyExistsException,
                                                             NotAuthorizedException

Use this endpoint to create a new Plan. Note that it is important to also create an initial version of the Plan (e.g. 1.0). This can either be done by including the 'initialVersion' property in the request, or by immediately following up with a call to "Create Plan Version". If the former is done, then a first Plan version will be created automatically by this endpoint.

Parameters:: organizationId - The Organization ID.; bean - Information about the new Plan.
Returns:: Full details about the newly created Plan.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; PlanAlreadyExistsException - when trying to create an Plan that already exists; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getPlan

@GET
@Path(value="{organizationId}/plans/{planId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.plans.PlanBean getPlan(@PathParam(value="organizationId")
                                                                   String organizationId,
                                                                   @PathParam(value="planId")
                                                                   String planId)
                                                   throws PlanNotFoundException,
                                                          NotAuthorizedException

Use this endpoint to retrieve information about a single Plan by ID. Note that this only returns information about the Plan, not about any particular *version* of the Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.
Returns:: An Plan. when trying to get, update, or delete an plan that does not exist
Throws:: PlanNotFoundException - when trying to get, update, or delete an plan that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getPlanActivity

@GET
@Path(value="{organizationId}/plans/{planId}/activity")
@Produces(value="application/json")
io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean> getPlanActivity(@PathParam(value="organizationId")
                                                                                                                                       String organizationId,
                                                                                                                                       @PathParam(value="planId")
                                                                                                                                       String planId,
                                                                                                                                       @QueryParam(value="page")
                                                                                                                                       int page,
                                                                                                                                       @QueryParam(value="count")
                                                                                                                                       int pageSize)
                                                                                                                       throws PlanNotFoundException,
                                                                                                                              NotAuthorizedException

This endpoint returns audit activity information about the Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; page - Which page of activity should be returned.; pageSize - The number of entries per page to return.
Returns:: A list of audit activity entries. when trying to get, update, or delete an plan that does not exist
Throws:: PlanNotFoundException - when trying to get, update, or delete an plan that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listPlans

@GET
@Path(value="{organizationId}/plans")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.PlanSummaryBean> listPlans(@PathParam(value="organizationId")
                                                                                    String organizationId)
                                                                    throws OrganizationNotFoundException,
                                                                           NotAuthorizedException

Use this endpoint to get a list of all Plans in the Organization.

Parameters:: organizationId - The Organization ID.
Returns:: A list of Plans.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

updatePlan

@PUT
@Path(value="{organizationId}/plans/{planId}")
@Consumes(value="application/json")
@Produces(value="application/json")
void updatePlan(@PathParam(value="organizationId")
                                         String organizationId,
                                         @PathParam(value="planId")
                                         String planId,
                                         io.apiman.manager.api.beans.plans.UpdatePlanBean bean)
                throws PlanNotFoundException,
                       NotAuthorizedException

Use this endpoint to update information about a Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; bean - Updated Plan information.
Throws:: PlanNotFoundException - when trying to get, update, or delete a plan that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createPlanVersion

@POST
@Path(value="{organizationId}/plans/{planId}/versions")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.plans.PlanVersionBean createPlanVersion(@PathParam(value="organizationId")
                                                                                              String organizationId,
                                                                                              @PathParam(value="planId")
                                                                                              String planId,
                                                                                              io.apiman.manager.api.beans.plans.NewPlanVersionBean bean)
                                                                    throws PlanNotFoundException,
                                                                           NotAuthorizedException

Use this endpoint to create a new version of the Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; bean - Initial information about the new Plan version.
Returns:: Full details about the newly created Plan version. when trying to get, update, or delete an plan that does not exist
Throws:: PlanNotFoundException - when trying to get, update, or delete an plan that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listPlanVersions

@GET
@Path(value="{organizationId}/plans/{planId}/versions")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.PlanVersionSummaryBean> listPlanVersions(@PathParam(value="organizationId")
                                                                                                  String organizationId,
                                                                                                  @PathParam(value="planId")
                                                                                                  String planId)
                                                                                  throws PlanNotFoundException,
                                                                                         NotAuthorizedException

Use this endpoint to list all of the versions of a Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.
Returns:: A list of Plans. when trying to get, update, or delete an plan that does not exist
Throws:: PlanNotFoundException - when trying to get, update, or delete an plan that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getPlanVersion

@GET
@Path(value="{organizationId}/plans/{planId}/versions/{version}")
@Produces(value="application/json")
io.apiman.manager.api.beans.plans.PlanVersionBean getPlanVersion(@PathParam(value="organizationId")
                                                                                 String organizationId,
                                                                                 @PathParam(value="planId")
                                                                                 String planId,
                                                                                 @PathParam(value="version")
                                                                                 String version)
                                                                 throws PlanVersionNotFoundException,
                                                                        NotAuthorizedException

Use this endpoint to get detailed information about a single version of a Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.
Returns:: An Plan version.
Throws:: PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getPlanVersionActivity

@GET
@Path(value="{organizationId}/plans/{planId}/versions/{version}/activity")
@Produces(value="application/json")
io.apiman.manager.api.beans.search.SearchResultsBean<io.apiman.manager.api.beans.audit.AuditEntryBean> getPlanVersionActivity(@PathParam(value="organizationId")
                                                                                                                                              String organizationId,
                                                                                                                                              @PathParam(value="planId")
                                                                                                                                              String planId,
                                                                                                                                              @PathParam(value="version")
                                                                                                                                              String version,
                                                                                                                                              @QueryParam(value="page")
                                                                                                                                              int page,
                                                                                                                                              @QueryParam(value="count")
                                                                                                                                              int pageSize)
                                                                                                                              throws PlanVersionNotFoundException,
                                                                                                                                     NotAuthorizedException

Use this endpoint to get audit activity information for a single version of the Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.; page - Which page of activity data to return.; pageSize - The number of entries per page to return.
Returns:: A list of audit entries.
Throws:: PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

createPlanPolicy

@POST
@Path(value="{organizationId}/plans/{planId}/versions/{version}/policies")
@Consumes(value="application/json")
@Produces(value="application/json")
io.apiman.manager.api.beans.policies.PolicyBean createPlanPolicy(@PathParam(value="organizationId")
                                                                                           String organizationId,
                                                                                           @PathParam(value="planId")
                                                                                           String planId,
                                                                                           @PathParam(value="version")
                                                                                           String version,
                                                                                           io.apiman.manager.api.beans.policies.NewPolicyBean bean)
                                                                 throws OrganizationNotFoundException,
                                                                        PlanVersionNotFoundException,
                                                                        NotAuthorizedException

Use this endpoint to add a new Policy to the Plan version.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.; bean - Information about the new Policy.
Returns:: Full details about the newly added Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

getPlanPolicy

@GET
@Path(value="{organizationId}/plans/{planId}/versions/{version}/policies/{policyId}")
@Produces(value="application/json")
io.apiman.manager.api.beans.policies.PolicyBean getPlanPolicy(@PathParam(value="organizationId")
                                                                              String organizationId,
                                                                              @PathParam(value="planId")
                                                                              String planId,
                                                                              @PathParam(value="version")
                                                                              String version,
                                                                              @PathParam(value="policyId")
                                                                              long policyId)
                                                              throws OrganizationNotFoundException,
                                                                     PlanVersionNotFoundException,
                                                                     PolicyNotFoundException,
                                                                     NotAuthorizedException

Use this endpoint to get information about a single Policy in the Plan version.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.; policyId - The Policy ID.
Returns:: Full information about the Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

updatePlanPolicy

@PUT
@Path(value="{organizationId}/plans/{planId}/versions/{version}/policies/{policyId}")
@Consumes(value="application/json")
@Produces(value="application/json")
void updatePlanPolicy(@PathParam(value="organizationId")
                                               String organizationId,
                                               @PathParam(value="planId")
                                               String planId,
                                               @PathParam(value="version")
                                               String version,
                                               @PathParam(value="policyId")
                                               long policyId,
                                               io.apiman.manager.api.beans.policies.UpdatePolicyBean bean)
                      throws OrganizationNotFoundException,
                             PlanVersionNotFoundException,
                             PolicyNotFoundException,
                             NotAuthorizedException

Use this endpoint to update the meta-data or configuration of a single Plan Policy.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.; policyId - The Policy ID.; bean - New meta-data and/or configuration for the Policy.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

deletePlanPolicy

@DELETE
@Path(value="{organizationId}/plans/{planId}/versions/{version}/policies/{policyId}")
void deletePlanPolicy(@PathParam(value="organizationId")
                                String organizationId,
                                @PathParam(value="planId")
                                String planId,
                                @PathParam(value="version")
                                String version,
                                @PathParam(value="policyId")
                                long policyId)
                      throws OrganizationNotFoundException,
                             PlanVersionNotFoundException,
                             PolicyNotFoundException,
                             NotAuthorizedException

Use this endpoint to remove a Policy from the Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.; policyId - The Policy ID.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; PolicyNotFoundException - when trying to get, update, or delete a policy that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listPlanPolicies

@GET
@Path(value="{organizationId}/plans/{planId}/versions/{version}/policies")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.summary.PolicySummaryBean> listPlanPolicies(@PathParam(value="organizationId")
                                                                                             String organizationId,
                                                                                             @PathParam(value="planId")
                                                                                             String planId,
                                                                                             @PathParam(value="version")
                                                                                             String version)
                                                                             throws OrganizationNotFoundException,
                                                                                    PlanVersionNotFoundException,
                                                                                    NotAuthorizedException

Use this endpoint to list all of the Policies configured for the Plan.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.
Returns:: A List of Policies.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

reorderPlanPolicies

@POST
@Path(value="{organizationId}/plans/{planId}/versions/{version}/reorderPolicies")
@Consumes(value="application/json")
void reorderPlanPolicies(@PathParam(value="organizationId")
                                          String organizationId,
                                          @PathParam(value="planId")
                                          String planId,
                                          @PathParam(value="version")
                                          String version,
                                          io.apiman.manager.api.beans.policies.PolicyChainBean policyChain)
                         throws OrganizationNotFoundException,
                                PlanVersionNotFoundException,
                                NotAuthorizedException

Use this endpoint to change the order of Policies for a Plan. When a Policy is added to the Plan, it is added as the last Policy in the list of Plan Policies. Sometimes the order of Policies is important, so it is often useful to re-order the Policies by invoking this endpoint. The body of the request should include all of the Policies for the Plan, in the new desired order. Note that only the IDs of each of the Policies is actually required in the request, at a minimum.

Parameters:: organizationId - The Organization ID.; planId - The Plan ID.; version - The Plan version.; policyChain - The Policies in the desired order.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; PlanVersionNotFoundException - when trying to get, update, or delete a plan version that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

grant
```
@POST
@Path(value="{organizationId}/roles")
@Consumes(value="application/json")
void grant(@PathParam(value="organizationId")
                            String organizationId,
                            io.apiman.manager.api.beans.idm.GrantRolesBean bean)
           throws OrganizationNotFoundException,
                  RoleNotFoundException,
                  UserNotFoundException,
                  NotAuthorizedException
```
Grant membership in a role to a user.

Parameters:
organizationId - The Organization ID.
bean - Roles to grant, and the ID of the user.

Throws:

OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist

RoleNotFoundException - when a request is sent for a role that does not exist

UserNotFoundException - when a request is sent for a user who does not exist

NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

revoke

@DELETE
@Path(value="{organizationId}/roles/{roleId}/{userId}")
void revoke(@PathParam(value="organizationId")
                      String organizationId,
                      @PathParam(value="roleId")
                      String roleId,
                      @PathParam(value="userId")
                      String userId)
            throws OrganizationNotFoundException,
                   RoleNotFoundException,
                   UserNotFoundException,
                   NotAuthorizedException

Revoke membership in a role.

Parameters:: organizationId - The organization ID.; roleId - The role ID.; userId - The user ID.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; RoleNotFoundException - when a request is sent for a role that does not exist; UserNotFoundException - when a request is sent for a user who does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

revokeAll

@DELETE
@Path(value="{organizationId}/members/{userId}")
void revokeAll(@PathParam(value="organizationId")
                         String organizationId,
                         @PathParam(value="userId")
                         String userId)
               throws OrganizationNotFoundException,
                      RoleNotFoundException,
                      UserNotFoundException,
                      NotAuthorizedException

Revoke all of a user's role memberships from the org.

Parameters:: organizationId - The organization ID.; userId - The user ID.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; RoleNotFoundException - when a request is sent for a role that does not exist; UserNotFoundException - when a request is sent for a user who does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

listMembers

@GET
@Path(value="{organizationId}/members")
@Produces(value="application/json")
List<io.apiman.manager.api.beans.members.MemberBean> listMembers(@PathParam(value="organizationId")
                                                                                 String organizationId)
                                                                 throws OrganizationNotFoundException,
                                                                        NotAuthorizedException

Lists all members of the organization.

Parameters:: organizationId - The organization ID.
Returns:: List of members.
Throws:: OrganizationNotFoundException - when trying to get, update, or delete an organization that does not exist; NotAuthorizedException - when the user attempts to do or see something that they are not authorized (do not have permission) to

Interface IOrganizationResource