@verdaccio/types

abort: () => void;

abort: () => void;

done: () => void;

constructor(config: {}, options: PluginOptions<T>);

[key: string]: AbbreviatedVersion;

name: string;

tag?: string;

version?: string;

jwt?: JWTOptions;

legacy: boolean;

[key: string]: AttachMentsItem;

content_type?: string;

data?: string;

length?: number;

shasum?: string;

version?: string;

file: string;

max_users: number;

email?: string;

name: string;

url?: string;

packageName: string;

packageVersion?: string;

tag?: string;

secret: string;

server_id: string;

user_agent?: string | boolean;

checkSecretKey: (token: string) => string;

getMatchedPackagesSpec: (storage: string) => PackageAccess | void;

[key: string]: any;

self_path: string;

https: HttpsConf;

auth?: AuthConf;

filters?: any;

http_proxy?: string;

https?: HttpsConf;

https_proxy?: string;

listen?: ListenAddress;

logs?: LoggerConfItem;

max_body_size?: string;

middlewares?: any;

no_proxy?: string;

notifications?: Notifications;

notify?: Notifications | Notifications[];

packages: PackageList;

plugins?: string | void | null;

publish?: PublishOptions;

security: Security;

server?: ServerSettingsConf;

storage?: string | void;

store?: any;

uplinks: UpLinksConfList;

url_prefix?: string;

web?: WebConf;

[key: string]: string;

integrity?: string;

shasum: string;

tarball: string;

registry?: string;

sha: string;

url: string;

[key: string]: DistFile;

[key: string]: string;

[key: string]: string;

[key: string]: string;

expose: boolean;

headers?: {
    [key: string]: string;
};

status: number;

statusCode: number;

[key: string]: any;

ca?: string;

cert: string;

key: string;

passphrase?: string;

pfx: string;

config: T & Config;

add_user: (user: string, password: string, cb: Callback) => any;

aesEncrypt: (username: string, password: string) => string;

allow_access: (
    pkg: AuthPluginPackage,
    user: RemoteUser,
    callback: Callback
) => void;

authenticate: (user: string, password: string, cb: Callback) => void;

changePassword: (
    user: string,
    password: string,
    newPassword: string,
    cb: Callback
) => void;

addPackage: (name: string, info: Package, callback: Callback) => void;

getPackageMetadata: (name: string, callback: Callback) => void;

getSecret: (config: T & Config) => Promise<any>;

search: (startKey: string, options: any) => IReadTarball;

updateVersions: (name: string, packageInfo: Package, callback: Callback) => void;

config: T & Config;

logger: Logger;

add: (name: string, callback: Callback) => void;

get: (callback: Callback) => void;

getPackageStorage: (packageInfo: string) => IPackageStorage;

getSecret: () => Promise<string>;

remove: (name: string, callback: Callback) => void;

search: (
    onPackage: onSearchPackage,
    onEnd: onEndSearchPackage,
    validateName: onValidatePackage
) => void;

setSecret: (secret: string) => Promise<any>;

logger: Logger;

createPackage: (pkgName: string, value: Package, cb: CallbackAction) => void;

deletePackage: (fileName: string, callback: CallbackAction) => void;

readPackage: (fileName: string, callback: ReadPackageCallback) => void;

readTarball: (pkgName: string) => IReadTarball;

removePackage: (callback: CallbackAction) => void;

savePackage: (fileName: string, json: Package, callback: CallbackAction) => void;

updatePackage: (
    pkgFileName: string,
    updateHandler: StorageUpdateCallback,
    onWrite: StorageWriteCallback,
    transformPackage: PackageTransformer,
    onEnd: CallbackAction
) => void;

writeTarball: (pkgName: string) => IUploadTarball;

add: (name: string) => void;

get: () => StorageList;

remove: (name: string) => void;

sync: () => void;

version?: string;

adduser: (user: string, password: string, cb: AuthCallback) => void;

allow_access: {
    (user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
    (
        user: RemoteUser,
        pkg: AllowAccess & PackageAccess,
        cb: AuthAccessCallback
    ): void;
};

allow_publish: {
    (user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
    (
        user: RemoteUser,
        pkg: AllowAccess & PackageAccess,
        cb: AuthAccessCallback
    ): void;
};

allow_unpublish: {
    (user: RemoteUser, pkg: T & PackageAccess, cb: AuthAccessCallback): void;
    (
        user: RemoteUser,
        pkg: AllowAccess & PackageAccess,
        cb: AuthAccessCallback
    ): void;
};

apiJWTmiddleware: (helpers: any) => Function;

authenticate: (user: string, password: string, cb: AuthCallback) => void;

changePassword: (
    user: string,
    password: string,
    newPassword: string,
    cb: AuthCallback
) => void;

register_middlewares: (
    app: any,
    auth: IBasicAuth<T>,
    storage: IStorageManager<T>
) => void;

filter_metadata: (packageInfo: Package) => Promise<Package>;

config: T & Config;

logger: Logger;

addPackage: (name: string, metadata: any, callback: Callback) => Promise<any>;

getLocalDatabase: (callback: Callback) => void;

getPackage: (options: any) => void;

init: (config: T & Config, filters: any) => Promise<any>;

search: (startkey: string, options: any) => IReadTarball;

deleteToken: (user: string, tokenKey: string) => Promise<any>;

readTokens: (filter: TokenFilter) => Promise<Token[]>;

saveToken: (token: Token) => Promise<any>;

sign: JWTSignOptions;

verify: JWTVerifyOptions;

algorithm?: string;

clockTimestamp?: number;

expiresIn?: string;

ignoreExpiration?: boolean;

maxAge?: string | number;

notBefore?: string;

algorithm?: string;

clockTimestamp?: number;

expiresIn?: string;

ignoreExpiration?: boolean;

maxAge?: string | number;

notBefore?: string | number;

[key: string]: string;

list: any;

secret: string;

child: (conf: any) => any;

debug: (conf: any, template?: string) => void;

error: (conf: any, template?: string) => void;

http: (conf: any, template?: string) => void;

info: (conf: any, template?: string) => void;

trace: (conf: any, template?: string) => void;

warn: (conf: any, template?: string) => void;

format: LoggerFormat;

level: LoggerLevel;

type: LoggerType;

'dist-tags': GenericBody;

name: string;

readme?: string;

time?: GenericBody;

users?: PackageUsers;

versions: Versions;

[key: string]: string;

content: string;

endpoint: string;

headers: Headers;

method: string;

packagePattern: RegExp;

packagePatternFlags: string;

access?: string[];

proxy?: string[];

publish?: string[];

storage?: string;

[key: string]: PackageAccess;

[key: string]: boolean;

[dependencyName: string]: {
    optional?: boolean;
};

config: T & Config;

logger: Logger;

allow_offline: boolean;

error?: string;

groups: string[];

name: string | void;

real_groups: string[];

api: APITokenOptions;

enhancedLegacySignature?: boolean;

web: JWTOptions;

cidr?: string[];

created: number | string;

key: string;

readonly: boolean;

token: string;

updated?: number | string;

user: string;

user: string;

auth?: UpLinkTokenConf;

ca?: string;

cache?: boolean;

fail_timeout?: string | void;

headers?: Headers;

max_fails?: number | void;

maxage?: string | void;

strict_ssl?: boolean | void;

timeout?: string | void;

url: string;

etag: string;

fetched: number;

[key: string]: UpLinkMetadata;

[key: string]: UpLinkConf;

token?: string;

token_env?: boolean | string;

type: TypeToken;

author: string | Author;

bin?: string;

bugs?: any;

bundleDependencies?: Dependencies;

contributors?: Author[];

cpu?: string[];

dependencies?: Dependencies;

deprecated?: string;

description: string;

devDependencies?: Dependencies;

directories?: any;

dist: Dist;

engines?: Engines;

etag?: string;

files?: string[];

funding?: {
    type: string;
    url: string;
};

gitHead?: string;

hasInstallScript?: boolean;

homemage?: string;

homepage?: string;

keywords?: string | string[];

license?: string;

main: string;

maintainers?: Author[];

name: string;

nodeVersion?: string;

optionalDependencies?: Dependencies;

os?: string[];

peerDependencies?: Dependencies;

peerDependenciesMeta?: PeerDependenciesMeta;

readme: string;

readmeFilename?: string;

readmeFileName?: string;