repository-provider 35.0.4 → 35.2.0

package/types/owned-object.d.mts

@@ -0,0 +1,132 @@
+/**
+ * Named Object registering itself in the owner.
+ */
+export class OwnedObject extends NamedObject {
+    /**
+     * Method name to be called to register one instance in the owner.
+     * sample: Application => _addApplication
+     * @return {string}
+     */
+    static get addMethodName(): string;
+    /**
+     * Method name to be called to unregister one instance in the owner.
+     * sample: Application => _deleteApplication
+     * @return {string}
+     */
+    static get deleteMethodName(): string;
+    constructor(owner: any, name: any, options: any, additionalProperties: any);
+    owner: any;
+    /**
+     * Removes the receiver from the owner.
+     */
+    delete(): void;
+    /**
+     * Check for equality.
+     * @param {OwnedObject} other
+     * @return {boolean} true if receiver and owner are equal
+     */
+    equals(other: OwnedObject): boolean;
+    /**
+     * Url of home page.
+     * @see {@link Repository#homePageURL}
+     * @return {string} as provided from the owner
+     */
+    get homePageURL(): string;
+    /**
+     * Url of issue tracking system.
+     * @see {@link Repository#issuesURL}
+     * @return {string} as provided from the repository
+     */
+    get issuesURL(): string;
+    /**
+     * Forwarded from the owner.
+     * @return {boolean}
+     */
+    get isLocked(): boolean;
+    /**
+     * Forwarded from the owner.
+     * @return {boolean}
+     */
+    get isArchived(): boolean;
+    /**
+     * Forwarded from the owner.
+     * @return {boolean}
+     */
+    get isDisabled(): boolean;
+    /**
+     * API as given by the owner.
+     * @return {string} url
+     */
+    get api(): string;
+    /**
+     * API as given by the owner.
+     * @return {string} url
+     */
+    get slug(): string;
+    /**
+     * URL as given by the owner.
+     * @return {string} url
+     */
+    get url(): string;
+    /**
+     * The provider we live in.
+     * @return {BaseProvider}
+     */
+    get provider(): BaseProvider;
+    /**
+     * Forwarded to the owner.
+     * @param  {...any} args
+     */
+    trace(...args: any[]): any;
+    /**
+     * Forwarded to the owner.
+     * @param  {...any} args
+     */
+    info(...args: any[]): any;
+    /**
+     * Forwarded to the owner.
+     * @param  {...any} args
+     */
+    warn(...args: any[]): any;
+    /**
+     * Forwarded to the owner.
+     * @param  {...any} args
+     */
+    error(...args: any[]): any;
+    /**
+     * Forwarded to the owner.
+     * @param  {...any} args
+     */
+    debug(...args: any[]): any;
+    /**
+     * By default we use the owners implementation.
+     * @return {Repository} as defined in the owner
+     */
+    get repositoryClass(): Repository;
+    /**
+     * By default we use the owners implementation.
+     * @return {PullRequest} as defined in the owner
+     */
+    get pullRequestClass(): PullRequest;
+    /**
+     * By default we use the owners implementation.
+     * @return {Branch} as defined in the owner
+     */
+    get branchClass(): Branch;
+    /**
+     * By default we use the owners implementation.
+     * @return {Tag} as defined in the owner
+     */
+    get tagClass(): Tag;
+    /**
+     * By default we use the owners implementation.
+     * @return {ContentEntry} as defined in the owner
+     */
+    get entryClass(): ContentEntry;
+    /**
+     * By default we use the owners implementation.
+     * @return {Hook} as defined in the owner
+     */
+    get hookClass(): Hook;
+}
+import { NamedObject } from "./named-object.mjs";

package/types/project.d.mts

@@ -0,0 +1,6 @@
+/**
+ *
+ */
+export class Project extends OwnedObject {
+}
+import { OwnedObject } from "./owned-object.mjs";

package/types/pull-request.d.mts

@@ -0,0 +1,233 @@
+/**
+ * Abstract pull request.
+ * {@link Repository#addPullRequest}
+ * @param {Branch} source merge source
+ * @param {Branch} owner merge target
+ * @param {string} name
+ * @param {Object} [options]
+ * @param {string} [options.title]
+ * @param {string} [options.state]
+ * @param {boolean} [options.merged]
+ * @param {boolean} [options.locked]
+
+ * @property {string} name
+ * @property {Branch} source
+ * @property {Branch} destination
+ * @property {string} [title]
+ * @property {string} [state]
+ * @property {boolean} [merged]
+ * @property {boolean} [locked]
+ * @property {string} url
+ */
+export class PullRequest extends OwnedObject {
+    /**
+     * States to list pull request by default
+     * @return {Set<string>} states to list by default
+     */
+    static defaultListStates: Set<string>;
+    /**
+     * possible states
+     * @enum {string}
+     */
+    static states: Set<string>;
+    /**
+     * All valid merge methods
+     * @return {Set<string>} valid merge methods.
+     * @enum {string}
+     */
+    static validMergeMethods: Set<any>;
+    /**
+     * List all pull request for a given repo.
+     * Result will be filtered by source branch, destination branch and states
+     * @param {Repository} repository
+     * @param {Object} [filter]
+     * @param {Branch?} [filter.source]
+     * @param {Branch?} [filter.destination]
+     * @param {Set<string>} [filter.states]
+     * @return {AsyncIterable<PullRequest>}
+     */
+    static list(repository: Repository, filter?: {
+        source?: Branch | null;
+        destination?: Branch | null;
+        states?: Set<string>;
+    }): AsyncIterable<PullRequest>;
+    /**
+     * Open a pull request
+     *
+     * @param {Branch} source
+     * @param {Branch} destination
+     * @param {Object} [options]
+     */
+    static open(source: Branch, destination: Branch, options?: any): Promise<PullRequest>;
+    static get attributes(): {
+        body: {
+            writable: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        title: {
+            description: string;
+            writable: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        url: {
+            description: string;
+            type: string;
+            writable: boolean;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        /**
+         * state of the pull request.
+         * - OPEN
+         * - MERGED
+         * - CLOSED
+         * @return {string}
+         */
+        state: {
+            default: string;
+            values: Set<string>;
+            writable: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        /**
+         * Locked state of the pull request.
+         * @return {boolean}
+         */
+        locked: {
+            writable: boolean;
+            default: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        /**
+         * Merged state of the pull request.
+         * @return {boolean}
+         */
+        merged: {
+            writable: boolean;
+            default: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        /**
+         * Draft state of the pull request.
+         * @return {boolean}
+         */
+        draft: {
+            writable: boolean;
+            default: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        dry: {
+            writable: boolean;
+            default: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        empty: {
+            type: string;
+            writable: boolean;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        id: {
+            isKey: boolean;
+            description: string;
+            type: string;
+            writable: boolean;
+            mandatory: boolean;
+            private: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        name: {
+            isKey: boolean;
+            type: string;
+            writable: boolean;
+            mandatory: boolean;
+            private: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        description: {
+            description: string;
+            writable: boolean;
+            type: string;
+            mandatory: boolean;
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+    };
+    source: any;
+    get destination(): any;
+    get number(): any;
+    get dry(): boolean;
+    /**
+     * @return {Repository} destination repository
+     */
+    get repository(): Repository;
+    /**
+     * Delete the pull request from the {@link Repository}.
+     * @see {@link Repository#deletePullRequest}
+     * @return {Promise}
+     */
+    delete(): Promise<any>;
+    /**
+     * Merge the pull request.
+     * @param {string} method
+     */
+    merge(method?: string): Promise<void>;
+    merged: boolean;
+    /**
+     * Decline the pull request.
+     */
+    decline(): Promise<void>;
+    /**
+     * @return {AsyncIterable<Review>}
+     */
+    reviews(): AsyncIterable<Review>;
+}
+import { OwnedObject } from "./owned-object.mjs";
+import { Repository } from "./repository.mjs";
+import { Review } from "./review.mjs";
+import { Branch } from "./branch.mjs";

package/types/ref.d.mts

@@ -0,0 +1,113 @@
+/**
+ * @typedef {Object} ContentEntry
+ * @property {string} name
+ *
+ */
+/**
+ * Base for Branch and Tag
+ */
+export class Ref extends OwnedObject {
+    /**
+     * options
+     */
+    static get attributes(): {
+        name: {
+            isKey: boolean;
+            type: string;
+            writable: boolean;
+            mandatory: boolean;
+            /**
+             * @typedef {Object} ContentEntry
+             * @property {string} name
+             *
+             */
+            /**
+             * Base for Branch and Tag
+             */
+            private: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+        /**
+         * Can the ref be modified.
+         * @return {boolean}
+         */
+        isProtected: {
+            writable: boolean;
+            default: boolean;
+            type: string;
+            mandatory: boolean;
+            /**
+             * @typedef {Object} ContentEntry
+             * @property {string} name
+             *
+             */
+            /**
+             * Base for Branch and Tag
+             */
+            private: boolean;
+            isKey: boolean;
+            additionalAttributes: any[];
+            env: any[];
+        };
+    };
+    static get attributeMapping(): {
+        protected: string;
+    };
+    get refType(): string;
+    /**
+     * Full ref path.
+     * @return {string} git ref of the Ref
+     */
+    get ref(): string;
+    /**
+     * Get sha of our ref.
+     * @return {Promise<string>} sha of the ref
+     */
+    get refId(): Promise<string>;
+    /**
+     * List entries of the branch.
+     * @param {string[]|string} [matchingPatterns]
+     * @return {AsyncGenerator<ContentEntry>} all matching entries in the branch
+     */
+    entries(matchingPatterns?: string[] | string): AsyncGenerator<ContentEntry>;
+    /**
+     * Get exactly one matching entry by name or undefine if no such entry is found.
+     * @param {string} name
+     * @return {Promise<ContentEntry|undefined>}
+     */
+    maybeEntry(name: string): Promise<ContentEntry | undefined>;
+    /**
+     * Get exactly one matching entry by name (throws if entry is not found).
+     * @param {string} name
+     * @return {Promise<ContentEntry>}
+     */
+    entry(name: string): Promise<ContentEntry>;
+    /**
+     * Ref owner.
+     * By default we provide the repository owner
+     * @see {@link Repository#owner}
+     * @return {Repository}
+     */
+    get repository(): Repository;
+    get identifier(): any;
+    /**
+     *
+     * @return false
+     */
+    get isProtected(): boolean;
+    /**
+     * Are we the default ref.
+     * @return {boolean} false
+     */
+    get isDefault(): boolean;
+    /**
+     * List all entries of the branch.
+     * @return {AsyncGenerator<ContentEntry>} all entries in the branch
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<ContentEntry>;
+}
+export type ContentEntry = {
+    name: string;
+};
+import { OwnedObject } from "./owned-object.mjs";

package/types/repository-group.d.mts

@@ -0,0 +1,59 @@
+declare const RepositoryGroup_base: {
+    new (): {
+        [x: string]: any;
+        "__#2@#repositories": Map<any, any>;
+        normalizeRepositoryName(name: string, forLookup: boolean): string;
+        repository(name?: string): Promise<import("./repository.mjs").Repository>;
+        repositories(patterns?: string | string[]): AsyncIterable<import("./repository.mjs").Repository>;
+        lookup(type: string, name?: string, split?: Function, defaultItem?: any): Promise<OwnedObject>;
+        list(type: string, patterns?: string | string[], split?: Function, defaultItem?: any): AsyncIterable<OwnedObject>;
+        createRepository(name: string, options?: any): Promise<import("./repository.mjs").Repository>;
+        addRepository(name: string, options?: any): Promise<import("./repository.mjs").Repository>;
+        _addRepository(repository: any): void;
+        deleteRepository(name: string): Promise<any>;
+        initializeRepositories(): void;
+        branch(name: string): Promise<import("./branch.mjs").Branch>;
+        branches(patterns?: string | string[]): AsyncIterable<import("./branch.mjs").Branch>;
+        tag(name: any): Promise<OwnedObject>;
+        tags(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        pullRequest(name: any): Promise<OwnedObject>;
+        pullRequests(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        project(name: any): Promise<OwnedObject>;
+        projects(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        application(name: any): Promise<OwnedObject>;
+        applications(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        milestone(name: any): Promise<OwnedObject>;
+        milestones(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        hook(name: any): Promise<OwnedObject>;
+        hooks(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+    };
+    [x: string]: any;
+};
+/**
+ * Abstract repository collection.
+ * @param {BaseProvider} provider
+ * @param {string} name of the group
+ * @param {Object} [options]
+ * @param {string} [options.description] human readable description
+ * @param {string} [options.id] internal id
+ * @param {string} [options.url] home
+ *
+ * @property {BaseProvider} provider
+ * @property {string} name
+ */
+export class RepositoryGroup extends RepositoryGroup_base {
+    static get addMethodName(): string;
+    static get deleteMethodName(): string;
+    static get type(): string;
+    static get collectionName(): string;
+    static get attributes(): any;
+    /**
+     * Map attributes between external and internal representation.
+     */
+    static get attributeMapping(): {};
+    get isAdmin(): boolean;
+    get areRepositoryNamesCaseSensitive(): any;
+    get areRepositoryGroupNamesCaseSensitive(): any;
+}
+import { OwnedObject } from "./owned-object.mjs";
+export {};

package/types/repository-owner.d.mts

@@ -0,0 +1,103 @@
+/**
+ * Mixin to define a class able to handle a collection of repositories.
+ * @param {Object} base to be extendet
+ */
+export function RepositoryOwner(base: any): {
+    new (): {
+        [x: string]: any;
+        "__#2@#repositories": Map<any, any>;
+        /**
+         * Normalizes a repository name.
+         * Strips branch away.
+         * @param {string} name
+         * @param {boolean} forLookup
+         * @return {string} normalized name
+         */
+        normalizeRepositoryName(name: string, forLookup: boolean): string;
+        /**
+         * Lookup a repository.
+         * @param {string} [name] of the repository may contain a #branch
+         * @return {Promise<Repository|undefined>}
+         */
+        repository(name?: string): Promise<Repository | undefined>;
+        /**
+         * List repositories for the owner.
+         * @param {string[]|string} [patterns]
+         * @return {AsyncIterable<Repository>} all matching repositories of the owner
+         */
+        repositories(patterns?: string[] | string): AsyncIterable<Repository>;
+        /**
+         * Lookup entity of a given type and name.
+         * @param {string} type
+         * @param {string} [name]
+         * @param {function} [split]
+         * @param {Object} [defaultItem]
+         * @returns {Promise<OwnedObject|undefined>} from a repository
+         */
+        lookup(type: string, name?: string, split?: Function, defaultItem?: any): Promise<OwnedObject | undefined>;
+        /**
+         * List entities for a given type and pattern.
+         * @param {string} type
+         * @param {string[]|string} [patterns]
+         * @param {function} [split]
+         * @param {Object} [defaultItem]
+         * @return {AsyncIterable<OwnedObject>} matching type and pattern
+         */
+        list(type: string, patterns?: string[] | string, split?: Function, defaultItem?: any): AsyncIterable<OwnedObject>;
+        /**
+         * Create a new {@link Repository} in the provider.
+         * If there is already if repository for the given name it will be returned.
+         * @param {string} name
+         * @param {Object} [options]
+         * @return {Promise<Repository>} newly created repository (if not already present)
+         */
+        createRepository(name: string, options?: any): Promise<Repository>;
+        /**
+         * Add a {@link Repository} to the group.
+         * Only adds the repository to the in memory representation (does not execute any provider actions).
+         * @param {string} name
+         * @param {Object} [options]
+         * @return {Promise<Repository>} newly created repository
+         */
+        addRepository(name: string, options?: any): Promise<Repository>;
+        _addRepository(repository: any): void;
+        /**
+         * Delete a repository.
+         * @param {string} name
+         * @return {Promise<any>}
+         */
+        deleteRepository(name: string): Promise<any>;
+        initializeRepositories(): void;
+        /**
+         * Lookup a branch.
+         * First lookup repository then the branch.
+         * If no branch was specified then the default branch will be delivered.
+         * @see {@link Repository#defaultBranch}
+         * @param {string} name with optional branch name as '#myBranchName'
+         * @return {Promise<Branch|undefined>}
+         */
+        branch(name: string): Promise<Branch | undefined>;
+        /**
+         * List branches for the owner.
+         * @param {string[]|string} [patterns]
+         * @return {AsyncIterable<Branch>} all matching branches of the owner
+         */
+        branches(patterns?: string[] | string): AsyncIterable<Branch>;
+        tag(name: any): Promise<OwnedObject>;
+        tags(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        pullRequest(name: any): Promise<OwnedObject>;
+        pullRequests(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        project(name: any): Promise<OwnedObject>;
+        projects(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        application(name: any): Promise<OwnedObject>;
+        applications(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        milestone(name: any): Promise<OwnedObject>;
+        milestones(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+        hook(name: any): Promise<OwnedObject>;
+        hooks(patterns: any): AsyncGenerator<OwnedObject, void, undefined>;
+    };
+    [x: string]: any;
+};
+import { Repository } from "./repository.mjs";
+import { OwnedObject } from "./owned-object.mjs";
+import { Branch } from "./branch.mjs";