@sap-ux/project-access 1.0.0

package/dist/types/cap/index.d.ts

@@ -0,0 +1,136 @@
+export declare type CapProjectType = 'CAPJava' | 'CAPNodejs';
+export interface CapCustomPaths {
+    app: string;
+    db: string;
+    srv: string;
+}
+declare type SELECT = {
+    SELECT: {
+        distinct?: true;
+        one?: boolean;
+        from: source;
+        columns?: column_expr[];
+        excluding?: string[];
+        where?: predicate;
+        having?: predicate;
+        groupBy?: expr[];
+        orderBy?: ordering_term[];
+        limit?: {
+            rows: number;
+            offset: number;
+        };
+    };
+};
+declare type source = (ref | SELECT) & {
+    as?: name;
+    join?: name;
+    on?: xpr;
+};
+declare type name = string;
+declare type operator = string;
+declare type predicate = _xpr;
+declare type _xpr = (expr | operator)[];
+declare type expr = ref | val | xpr | SELECT;
+declare type ref = {
+    ref: (name & {
+        id?: string;
+        where?: expr;
+        args?: expr[];
+    })[];
+};
+declare type val = {
+    val: any;
+};
+declare type xpr = {
+    xpr: _xpr;
+};
+declare type ordering_term = expr & {
+    asc?: true;
+    desc?: true;
+};
+declare type column_expr = expr & {
+    as?: name;
+    cast?: any;
+    expand?: column_expr[];
+    inline?: column_expr[];
+};
+/** A parsed model. */
+export declare type csn = CSN;
+export interface CSN {
+    /** The assigned namespace. If parsed from multiple sources, this is the topmost model's namespace, if any, not the ones of imported models. */
+    namespace?: string;
+    /** The list of usings in this parsed model. Not available after imports have been resolved into a merged model. */
+    using?: {
+        name: string;
+        as?: string;
+        from?: string;
+    }[];
+    /** All definitions in the model including those from imported models. */
+    definitions?: Definitions;
+    /** All extensions in the model including those from imported models. Not available after extensions have been applied. */
+    extensions?: Definition[];
+    $sources?: string[];
+}
+interface DefinitionRegistry {
+    type: Type;
+    struct: Struct;
+    entity: Entity;
+    Association: Association;
+}
+declare type Definition = DefinitionRegistry[keyof DefinitionRegistry];
+interface Definitions {
+    [name: string]: Definition;
+}
+declare type kind = 'context' | 'service' | 'type' | 'entity' | 'element' | 'const' | 'annotation';
+declare type Element = Type & Struct & Association & {
+    kind: 'element' | undefined;
+};
+interface Type {
+    kind?: kind;
+    type?: string;
+    name: string;
+}
+interface Struct extends Type {
+    /** structs have elements which are in turn Definitions */
+    elements: {
+        [name: string]: Element;
+    };
+    /** References to definitions to be included. Not available after extensions have been applied. */
+    include?: string[];
+}
+interface Entity extends Struct {
+    kind: 'entity';
+    /** Entities with a query signify a view */
+    query?: SELECT & {
+        cql: string;
+    };
+    /** Elements of entities may have additional qualifiers */
+    elements: {
+        [name: string]: Element & {
+            key?: boolean;
+            virtual?: boolean;
+            unique?: boolean;
+            notNull?: boolean;
+        };
+    };
+    keys: {
+        [name: string]: Definition;
+    };
+}
+interface Association extends Type {
+    type: 'cds.Association' | 'cds.Composition';
+    /** The fully-qualified name of the Association's target entity */
+    target: string;
+    /** The specified cardinality. to-one = {max:1}, to-many = {max:'*'} */
+    cardinality?: {
+        src?: 1;
+        min?: 1 | 0;
+        max?: 1 | '*';
+    };
+    /** The parsed on condition in case of unmanaged Associations */
+    on?: predicate;
+    /** The optionally specified keys in case of managed Associations */
+    keys?: column_expr[];
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/cap/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/types/find/index.d.ts

@@ -0,0 +1,8 @@
+import type { Manifest } from '../webapp';
+export interface AllAppResults {
+    appRoot: string;
+    projectRoot: string;
+    manifestPath: string;
+    manifest: Manifest;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/find/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cap';
+export * from './package';
+export * from './find';
+export * from './vscode';
+export * from './webapp';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cap"), exports);
+__exportStar(require("./package"), exports);
+__exportStar(require("./find"), exports);
+__exportStar(require("./vscode"), exports);
+__exportStar(require("./webapp"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/package/basic.d.ts

@@ -0,0 +1,47 @@
+/**
+Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+export declare type Class<T, Arguments extends unknown[] = any[]> = Constructor<T, Arguments> & {
+    prototype: T;
+};
+/**
+Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+export declare type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
+/**
+Matches a JSON object.
+
+This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
+
+@category JSON
+*/
+export declare type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+/**
+Matches a JSON array.
+
+@category JSON
+*/
+export declare type JsonArray = JsonValue[];
+/**
+Matches any valid JSON primitive value.
+
+@category JSON
+*/
+export declare type JsonPrimitive = string | number | boolean | null;
+/**
+Matches any valid JSON value.
+
+@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
+
+@category JSON
+*/
+export declare type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+//# sourceMappingURL=basic.d.ts.map

package/dist/types/package/basic.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=basic.js.map

package/dist/types/package/index.d.ts

@@ -0,0 +1,12 @@
+import type { PackageJson } from './package-json';
+interface SapUxPackage {
+    sapux?: boolean | string[];
+    sapuxLayer?: UI5FlexLayer;
+    cds?: object;
+    ui5?: object;
+    remarkConfig?: object;
+}
+export declare type UI5FlexLayer = 'VENDOR' | 'CUSTOMER_BASE';
+export declare type Package = PackageJson & SapUxPackage;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/package/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/types/package/literal-union.d.ts

@@ -0,0 +1,32 @@
+import type { Primitive } from './primitive';
+/**
+Allows creating a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union.
+
+Currently, when a union type of a primitive type is combined with literal types, TypeScript loses all information about the combined literals. Thus, when such type is used in an IDE with autocompletion, no suggestions are made for the declared literals.
+
+This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729). It will be removed as soon as it's not needed anymore.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+// Before
+
+type Pet = 'dog' | 'cat' | string;
+
+const pet: Pet = '';
+// Start typing in your TypeScript-enabled IDE.
+// You **will not** get auto-completion for `dog` and `cat` literals.
+
+// After
+
+type Pet2 = LiteralUnion<'dog' | 'cat', string>;
+
+const pet: Pet2 = '';
+// You **will** get auto-completion for `dog` and `cat` literals.
+```
+
+@category Type
+*/
+export declare type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+//# sourceMappingURL=literal-union.d.ts.map

package/dist/types/package/literal-union.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=literal-union.js.map