@microtronics/studio-cli 0.9.1 → 0.11.0

package/dist/studio-cli.d.ts

@@ -3,6 +3,118 @@ import { Range as Range_2 } from 'yaml';
 import { SemVer } from 'semver';
 import { URI } from 'vscode-uri';
 
+export declare namespace APM {
+    export enum TagPhase {
+        release = "release",
+        stage = "stage",
+        passive = "passive",
+        withdrawn = "withdrawn"
+    }
+    /**
+     * The APM parts that are predefined
+     */
+    export enum Part {
+        dde = "dde",
+        dlo = "dlo",
+        pov = "pov",
+        blo = "blo"
+    }
+    export interface TagHeader extends ApplicationTagInformation {
+        author: string;
+        version: string;
+        blo_level?: Manifest.BloAccessLevel;
+        required_be?: string;
+        required_hwfw?: string;
+        required_productcode?: string;
+    }
+    export interface DevTagHeader {
+        name: string;
+        abstract: string;
+        author: string;
+        pip_id: string;
+        pov_location: Manifest.PovLocation;
+        pov_details_lowlevel: boolean;
+        blo_level: Manifest.BloAccessLevel;
+        blo_autostart: boolean;
+        /**
+         * ONE specific
+         * the version 0 for ONE
+         */
+        version?: number;
+        /**
+         * ONE specific
+         * owner_id is the organizationID
+         */
+        owner_id?: string;
+        required_be?: string;
+        required_hwfw?: string;
+        required_productcode?: string;
+    }
+    /**
+     * Create new release tag
+     * @param cwd
+     * @param fs
+     * @param phase
+     */
+    export function createTag(cwd: URI, fs: LocalFS, phase: TagPhase): Promise<FormData>;
+    /**
+     * Create new dev tag.
+     * @param cwd
+     * @param fs
+     */
+    export function createDevTag(cwd: URI, fs: LocalFS): Promise<FormData>;
+    /**
+     * create FormData object that can be pushed to the store
+     * @private
+     * @param cwd
+     * @param fs
+     * @param manifest
+     * @param tagHeader
+     */
+    export function createBuffer(cwd: URI, fs: LocalFS, manifest: Manifest.Manifest, tagHeader: TagHeader | DevTagHeader): Promise<FormData>;
+    export type ApplicationAccessInformation = Registry.ApplicationDetailInformation & {
+        id: string;
+    };
+    /**
+     * Validate if the current user has access to the apm
+     */
+    export function validateAccess(cwd: URI, fs: LocalFS, token: Registry.AuthToken, preventCreation: boolean, env: Globals.ENV): Promise<ApplicationAccessInformation | null>;
+    /**
+     *
+     * @param cwd
+     * @param fs
+     * @param token
+     * @param manifest
+     * @param env
+     */
+    export function registerNew(cwd: URI, fs: LocalFS, token: Registry.AuthToken, manifest: Manifest.Manifest, env: Globals.ENV): Promise<string>;
+    /**
+     * Update the APM profile
+     * - allowedBackends, description and name will be upated
+     * @param cwd
+     * @param fs
+     * @param token
+     * @param env
+     */
+    export function updateProfile(cwd: URI, fs: LocalFS, token: Registry.AuthToken, env: Globals.ENV): Promise<void>;
+    /**
+     * Publish a new version to the store
+     * @param cwd
+     * @param fs
+     * @param token
+     * @param apmTag
+     * @param env
+     */
+    export function publishTag(cwd: URI, fs: LocalFS, token: Registry.AuthToken, apmTag: FormData, env: Globals.ENV): Promise<{
+        tag_stamp: string;
+        version: number | string;
+        phase: string;
+        phase_stamp: string;
+    }>;
+}
+
+declare type ApplicationTagInformation = components['schemas']['ApplicationTagInformation'];
+
 declare interface components {
     schemas: {
         /** @default 25 */
@@ -114,7 +226,7 @@ declare interface components {
             phase: components["schemas"]["ReleasePhases"];
             /** @enum {string} */
             pov_location: "$embedded" | "$pure";
-            version: number;
+            version: string | number;
         };
         ApplicationVersionUpdate: {
             phase: components["schemas"]["ReleasePhases"];
@@ -209,8 +321,9 @@ declare interface components {
         LibraryFileName: "library.tar.gz" | "README.md" | "CHANGELOG.md" | "studio.json";
         /** @description Unique library id for this publisher */
         ApplicationId: string;
-        /** @description version of the application. */
-        ApplicationVersion: number;
+        /** @description version of the application. Either integer or for new applications semver */
+        ApplicationVersion: string | number;
+        ApplicationVersionInSemver: boolean;
         /** @description version of the library. Formatted as semantic version */
         ApplicationFileName: "release-notes.md";
         /** @description User Id */
@@ -1396,6 +1509,14 @@ export declare namespace DefaultFiles {
             mainDFILES: string;
         };
     };
+    /**
+     * Changelog.md
+     */
+    const readme: (name: string) => string;
+    /**
+     * Changelog.md
+     */
+    const changelog = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).";
 }
 
 export declare namespace Dependencies {
@@ -1700,6 +1821,14 @@ declare enum FileType {
 }
 
 export declare namespace Globals {
+    /**
+     * Supported ENV for the studio environment
+     */
+    export enum ENV {
+        lucky = "lucky",
+        winny = "winny",
+        production = "production"
+    }
     export interface Defines {
         [key: string]: string;
     }
@@ -1759,6 +1888,45 @@ export declare namespace Helper {
      * @param v
      */
     const isNumeric: (v: any) => boolean;
+    /**
+     * Convert an uint8Array to a base64 string
+     * @param bytes
+     */
+    export function bufferToBase64(bytes: Uint8Array): string;
+    /**
+     * Parse and resolve any {index} or {index+X} within the given value
+     * @param valueToPatch
+     * @param arrayIndex
+     */
+    export function patchValueWithArrayInfo(valueToPatch: any, arrayIndex: number): any;
+}
+
+export declare namespace Library {
+    /**
+     * Creates the library.tar.gz archive content
+     * @param cwd
+     * @param fs
+     */
+    export function createArchive(cwd: URI, fs: LocalFS): Promise<Uint8Array>;
+    /**
+     * Reads the project directory and returns all files that will be packed within the library.tar.gz
+     * @param cwd
+     * @param fs
+     */
+    export function getFilesForArchive(cwd: URI, fs: LocalFS): Promise<{
+        name: string;
+        data: Uint8Array;
+        modifyTime: Date;
+    }[]>;
+    /**
+     * Publish new library package to the registry
+     * @param cwd
+     * @param fs
+     * @param token
+     * @param archive
+     * @param env
+     */
+    export function publishPackage(cwd: URI, fs: LocalFS, token: Registry.AuthToken, archive: Uint8Array, env?: Globals.ENV): Promise<void>;
 }
 
 declare interface LocalFS {
@@ -1835,7 +2003,7 @@ export declare namespace Manifest {
         pov?: {
             details?: ApmPartScripts;
         };
-        blo?: ApmPartScripts;
+        blo?: BloSettings;
     }
     export interface Dependencies {
         [key: string]: string;
@@ -1844,12 +2012,29 @@ export declare namespace Manifest {
         buildCommand: string;
         workingPath: string;
     }
+    export enum BloAccessLevel {
+        restricted = "restricted",
+        global = "global"
+    }
+    export interface BloSettings extends ApmPartScripts {
+        accessLevel?: BloAccessLevel;
+    }
+    export enum PovLocation {
+        embedded = "$embedded",
+        pure = "$pure"
+    }
     /**
      * Read the studio.json manifest and parse it
      * @param cwd
      * @param fs
      */
     export function read(cwd: URI, fs: LocalFS): Promise<Manifest>;
+    /**
+     * Reads the studio.json as an uint8array
+     * @param cwd
+     * @param fs
+     */
+    export function readAsBlob(cwd: URI, fs: LocalFS): Promise<Uint8Array>;
     /**
      * Write the manifest to the workspace
      * @param cwd
@@ -1861,25 +2046,2166 @@ export declare namespace Manifest {
      * Check if the current project is a library project
      */
     export function isLibraryProject(manifest: Manifest.Manifest): boolean;
+    /**
+     * Validates if the properties within
+     * @param cwd
+     * @param fs
+     * @param manifest
+     * @param env
+     */
+    export function validateManifest(cwd: URI, fs: LocalFS, manifest: Manifest.Manifest | null, env?: Globals.ENV): Promise<void>;
+    export function validateLibraryName(libraryName: string): false | "Library name can only contain 'a' through 'z', '0' through '9', '_' and '-'. The Library name must start with an alphabetic or numeric character." | "The library name is beyond permissible length of 20 characters.";
+    export function validateProjectName(name: string, isLibrary?: boolean): Promise<false | "Library name can only contain 'a' through 'z', '0' through '9', '_' and '-'. The Library name must start with an alphabetic or numeric character." | "The library name is beyond permissible length of 20 characters." | "Project name can only contain 'A' through 'Z', 'a' through 'z', '0' through '9', ' ', '_' and '-'. The Project name must start with an alphabetic or numeric character." | "The project name is beyond permissible length of 40 characters.">;
+    export function validateDescription(description: string): Promise<false | "The description must have at least 5 characters.">;
+    export function validatePublisherId(publisher: string): Promise<false | "No publisher set yet" | "Publisher can only contain 'A' through 'Z', 'a' through 'z', '0' through '9' and '-'. The Publisher start with an alphabetic or numeric character.">;
+    export function validatePublisherOnline(token: Registry.AuthToken, publisher: string): Promise<string | false>;
+    export function validateRegistryAllowedBackends(allowedBackends: undefined | null | string | string[]): Promise<string | false>;
 }
 
-export declare namespace Registry {
+export declare namespace Package {
     /**
-     * Get the actual api url based on the STUDIO_ENV
+     * Build the whole project or only a specific part
+     * @param cwd
+     * @param fs
+     * @param apmPart - choose a specific part that should be build
      */
-    const getAPIUrl: () => {
-        baseUrl: string;
-    };
-    export type LibraryProfile = components['schemas']['LibraryDetailInformation'];
-    export type LibraryVersion = components['schemas']['LibraryVersion'];
+    export function buildAll(cwd: URI, fs: LocalFS, apmPart?: APM.Part): Promise<void>;
     /**
-     * Fetch the library profile of the given library
+     * Trigger the release based on the manifest settings
+     * @param cwd
+     * @param fs
      * @param token
-     * @param publisherId
-     * @param libraryId
+     * @param releasePhase
+     * @param env
+     */
+    export function release(cwd: URI, fs: LocalFS, token: Registry.AuthToken, releasePhase: APM.TagPhase, env?: Globals.ENV): Promise<void>;
+    /**
+     * Publish an application model tag
+     * @param cwd
+     * @param fs
+     * @param manifest
+     * @param token
+     * @param releasePhase
+     * @param env
+     */
+    export function releaseAPM(cwd: URI, fs: LocalFS, token: Registry.AuthToken, releasePhase: APM.TagPhase, env?: Globals.ENV): Promise<void>;
+    /**
+     * Publish a library project
+     * @param cwd
+     * @param fs
+     * @param manifest
+     * @param token
+     * @param env
+     */
+    export function releaseLibrary(cwd: URI, fs: LocalFS, token: Registry.AuthToken, env?: Globals.ENV): Promise<void>;
+    /**
+     * Read the projects README.md file
+     * validates if the file content is the initial content
+     * @param cwd
+     * @param fs
+     * @param projectName
+     */
+    export function getReadmeFile(cwd: URI, fs: LocalFS, projectName: string): Promise<Uint8Array>;
+    /**
+     * Read the projects CHANGELOG.md file
+     * validates if the file content is the initial content
+     * @param cwd
+     * @param fs
+     */
+    export function getChangelogFile(cwd: URI, fs: LocalFS): Promise<Uint8Array>;
+    /**
+     * Validate manifest settings that are required for the APM
+     * @param token
+     * @param manifest
      */
-    export function getLibraryProfile(token: string | null, publisherId: string, libraryId: string): Promise<LibraryProfile>;
-    export function fetchLibraryContent(token: string | null, contentURL: string, json?: boolean): Promise<any>;
+    export function validateSpecificSettings(token: Registry.AuthToken, manifest: Manifest.Manifest): Promise<void>;
+}
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+declare interface paths {
+    "/libraries": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a list of all accessible libraries */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Limit the amount of entities that will be returned in the data array */
+                    limit?: components["parameters"]["PaginationLimit"];
+                    /** @description Set the offset to skip the given amount of entities in the database */
+                    offset?: components["parameters"]["PaginationOffset"];
+                    /** @description Id of the publisher */
+                    publisherId?: components["parameters"]["PublisherIdQuery"];
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            meta?: components["schemas"]["ResultMeta"];
+                            data?: [
+                            components["schemas"]["LibraryListInformation"]
+                            ];
+                        };
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/applications": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a list of all accessible applications */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Limit the amount of entities that will be returned in the data array */
+                    limit?: components["parameters"]["PaginationLimit"];
+                    /** @description Set the offset to skip the given amount of entities in the database */
+                    offset?: components["parameters"]["PaginationOffset"];
+                    /** @description Id of the publisher */
+                    publisherId?: components["parameters"]["PublisherIdQuery"];
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            meta?: components["schemas"]["ResultMeta"];
+                            data?: [
+                            components["schemas"]["ApplicationListInformation"]
+                            ];
+                        };
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/publisher": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a list of all publishers. Security is optional. */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Limit the amount of entities that will be returned in the data array */
+                    limit?: components["parameters"]["PaginationLimit"];
+                    /** @description Set the offset to skip the given amount of entities in the database */
+                    offset?: components["parameters"]["PaginationOffset"];
+                    /** @description Get all publishers that have the given id as member. Authentication required for this call! */
+                    memberId?: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            meta?: components["schemas"]["ResultMeta"];
+                            data?: [
+                            components["schemas"]["Publisher"]
+                            ];
+                        };
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unauthorized */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /** Add a new publisher */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["NewPublisher"];
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description The id of the newly created publisher */
+                            id?: string;
+                        };
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/publisher/{publisherId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get the profile of the given publisherId. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Publisher"];
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/publisher/{publisherId}/libraries/{libraryId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get the profile of the given library. Security is optional. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    libraryId: components["parameters"]["LibraryId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["LibraryDetailInformation"];
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        /** Remove the given library from the registry. Publisher owner privileges needed! */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    libraryId: components["parameters"]["LibraryId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/publisher/{publisherId}/applications/{applicationId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get the profile of the given application. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: {
+                    "X-Semver"?: components["parameters"]["ApplicationVersionInSemver"];
+                };
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    applicationId: components["parameters"]["ApplicationId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ApplicationDetailInformation"];
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/packages/{publisherId}/libraries/{libraryId}/versions/{libraryVersion}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Add a new library version to the registry */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    libraryId: components["parameters"]["LibraryId"];
+                    /** @description version of the library. Formatted as semantic version */
+                    libraryVersion: components["parameters"]["LibraryVersion"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "multipart/form-data": {
+                        /**
+                         * Format: binary
+                         * @description The studio.json file of the library
+                         */
+                        "studio.json"?: string;
+                        /**
+                         * Format: binary
+                         * @description The library packed and compressed as tar.gz
+                         */
+                        "library.tar.gz"?: string;
+                        /**
+                         * Format: binary
+                         * @description An optional README file that describes your library in detail
+                         */
+                        "README.md"?: string;
+                        /**
+                         * Format: binary
+                         * @description An optional Chan
+                         */
+                        "CHANGELOG.md"?: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description conflict */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/packages/{publisherId}/libraries/{libraryId}/versions/{libraryVersion}/files/{fileName}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Download a specific file of a library. Security is optional. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    libraryId: components["parameters"]["LibraryId"];
+                    /** @description version of the library. Formatted as semantic version */
+                    libraryVersion: components["parameters"]["LibraryVersion"];
+                    /** @description Filename that can be fetched */
+                    libraryFileName: components["parameters"]["LibraryFileName"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/gzip": string;
+                        "text/markdown": string;
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/packages/{publisherId}/applications": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Add a new application to the registry */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["NewApplication"];
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description The newly generated application id */
+                            id?: string;
+                        };
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description conflict */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/packages/{publisherId}/applications/{applicationId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Update the profile of an existing application */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    applicationId: components["parameters"]["ApplicationId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["NewApplication"];
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description conflict */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/packages/{publisherId}/applications/{applicationId}/versions/{applicationVersion}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Update the release phase of an existing version */
+        put: {
+            parameters: {
+                query?: never;
+                header?: {
+                    "X-Semver"?: components["parameters"]["ApplicationVersionInSemver"];
+                };
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    applicationId: components["parameters"]["ApplicationId"];
+                    /** @description version of the application. Either integer or for new applications semver */
+                    applicationVersion: components["parameters"]["ApplicationVersion"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["ApplicationVersionUpdate"];
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description conflict */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        /** Add a new application version to the registry */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    "X-Semver"?: components["parameters"]["ApplicationVersionInSemver"];
+                };
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    applicationId: components["parameters"]["ApplicationId"];
+                    /** @description version of the application. Either integer or for new applications semver */
+                    applicationVersion: components["parameters"]["ApplicationVersion"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "multipart/form-data": {
+                        tag: components["schemas"]["ApplicationTagInformation"];
+                        /**
+                         * Format: binary
+                         * @description The xml representation of the DDE
+                         */
+                        "bin/dde/xml": string;
+                        /**
+                         * Format: binary
+                         * @description The compiled dlo binary
+                         */
+                        "bin/dlo/amx": string;
+                    };
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** Format: date-time */
+                            tag_stamp: string;
+                            version: number | string;
+                            phase: string;
+                            /** Format: date-time */
+                            phase_stamp: string;
+                        };
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description conflict */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @description Information about what went/is wrong */
+                            err: string;
+                        };
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/packages/{publisherId}/applications/{applicationId}/versions/{applicationVersion}/files/{fileName}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Download a specific file of the application tag. */
+        get: {
+            parameters: {
+                query?: never;
+                header?: {
+                    "X-Semver"?: components["parameters"]["ApplicationVersionInSemver"];
+                };
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    applicationId: components["parameters"]["ApplicationId"];
+                    /** @description version of the application. Either integer or for new applications semver */
+                    applicationVersion: components["parameters"]["ApplicationVersion"];
+                    /** @description version of the library. Formatted as semantic version */
+                    applicationFileName: components["parameters"]["ApplicationFileName"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/gzip": string;
+                        "text/markdown": string;
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /** Upload a specific file for the application tag. */
+        post: {
+            parameters: {
+                query?: never;
+                header?: {
+                    "X-Semver"?: components["parameters"]["ApplicationVersionInSemver"];
+                };
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description Unique library id for this publisher */
+                    applicationId: components["parameters"]["ApplicationId"];
+                    /** @description version of the application. Either integer or for new applications semver */
+                    applicationVersion: components["parameters"]["ApplicationVersion"];
+                    /** @description version of the library. Formatted as semantic version */
+                    applicationFileName: components["parameters"]["ApplicationFileName"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/octet-stream": string;
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/publisher/{publisherId}/members": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get the member list of the given publisher */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PublisherMemberListInformation"];
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /** Add a member to the given publisher */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["NewPublisherMember"];
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description bad request */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Given member is already a member */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/publisher/{publisherId}/members/{memberId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** Change the role of the given member from the publishers member list */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description User Id */
+                    memberId: components["parameters"]["MemberId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["ChangePublisherRole"];
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        post?: never;
+        /** Remove the given member from the publishers member list */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                    /** @description User Id */
+                    memberId: components["parameters"]["MemberId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cloudstudio/publisher/{publisherId}/assign-application": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Transfer Store ownership to the given publisher */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the publisher */
+                    publisherId: components["parameters"]["PublisherId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["CloudStudioApplicationAssign"];
+                };
+            };
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description bad request */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Given member is already a member */
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/cloudstudio/applications/{applicationId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Validate if the given applicationId is already assigned to a publisher */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Unique library id for this publisher */
+                    applicationId: components["parameters"]["ApplicationId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Publisher"];
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/users/{userId}/manage/api-tokens": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get the api tokens of the given user */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description User Id */
+                    userId: components["parameters"]["UserId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Successful operation */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": [
+                        components["schemas"]["ApiToken"]
+                        ];
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        /** Create a new api token for the given userid */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description User Id */
+                    userId: components["parameters"]["UserId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": components["schemas"]["NewApiToken"];
+                };
+            };
+            responses: {
+                /** @description Successful operation */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ApiTokenCreated"];
+                    };
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description forbidden */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/users/{userId}/manage/api-tokens/{tokenId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Remove the given api token */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description User Id */
+                    userId: components["parameters"]["UserId"];
+                    /** @description Id of theapi token */
+                    tokenId: components["parameters"]["TokenId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description successful operation */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description bad request */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description unprocessable entity */
+                422: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description internal Server Error */
+                500: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+
+export declare namespace Registry {
+    export type AuthToken = string | null;
+    /**
+     * Get the actual api url based on the STUDIO_ENV
+     */
+    const getAPIUrl: () => {
+        baseUrl: string;
+    };
+    export type LibraryProfile = components['schemas']['LibraryDetailInformation'];
+    export type LibraryVersion = components['schemas']['LibraryVersion'];
+    /**
+     * Fetch the library profile of the given library
+     * @param token
+     * @param publisherId
+     * @param libraryId
+     */
+    export function getLibraryProfile(token: AuthToken, publisherId: string, libraryId: string): Promise<LibraryProfile>;
+    export function fetchLibraryContent(token: AuthToken, contentURL: string, json?: boolean): Promise<any>;
+    export type Publisher = components['schemas']['Publisher'];
+    export function getPublisher(token: AuthToken, publisherId: string): Promise<Publisher | null>;
+    export type ApiNewApplication = components['schemas']['NewApplication'];
+    export function createNewApplication(token: AuthToken, publisherId: string, newApplication: ApiNewApplication, env?: Globals.ENV): Promise<string | null | undefined>;
+    export type ApplicationDetailInformation = components['schemas']['ApplicationDetailInformation'];
+    export function getExistingApplication(token: AuthToken, publisherId: string, applicationId: string, env?: Globals.ENV): Promise<ApplicationDetailInformation>;
+    export function updateExistingApplication(token: AuthToken, publisherId: string, applicationId: string, updatedApplication: ApiNewApplication, env?: Globals.ENV): Promise<null | undefined>;
+    export type CreatedTagInfo = paths['/packages/{publisherId}/applications/{applicationId}/versions/{applicationVersion}']['post']['responses']['201']['content']['application/json'];
+    export function publishApplicationVersion(token: AuthToken, publisherId: string, applicationId: string, version: string, apmTagBuffer: FormData, env?: Globals.ENV): Promise<CreatedTagInfo>;
+    export type LibraryFiles = {
+        'studio.json': Uint8Array;
+        'library.tar.gz': Uint8Array;
+        'README.md': Uint8Array;
+        'CHANGELOG.md': Uint8Array;
+    };
+    export function publishLibraryVersion(token: AuthToken, publisherId: string, libraryId: string, libraryVersion: string, files: LibraryFiles, env?: Globals.ENV): Promise<void>;
 }
 
 declare function uriToMemFsPath(path: URI): string;