@servicenow/sdk-build-core 3.0.3 → 4.0.0

package/dist/plugins/shape.d.ts

@@ -0,0 +1,424 @@
+import { type Source, Product } from './product';
+import { ts } from '../typescript';
+import type { Plugin } from './plugin';
+import type { InstallCategory } from './file';
+export type ShapeClass<P extends Shape = Shape> = (abstract new (...args: any[]) => P) & {
+    prototype: P;
+};
+export declare abstract class Shape<T = unknown> extends Product {
+    constructor({ source }: {
+        source: Source;
+    });
+    /**
+     * Instantiate an appropriate shape from the given value. If the value is already
+     * a shape, it will be returned as-is.
+     */
+    static from(source: Source, value: unknown): Shape;
+    /**
+     * Instantiate a NoOpShape which has no value and will not generate or update
+     * any code. Useful for shapes that are not supported for bidirectional sync.
+     */
+    static noOp(source: Source): NoOpShape;
+    /**
+     * Gets the value of the shape.
+     */
+    getValue(): T;
+    equals(value: unknown): boolean;
+    pipe<T>(pipeFn: (shape: this) => T): T;
+    isResolvable(): this is ResolvableShape;
+    isIdentifier(): this is IdentifierShape;
+    isString(): this is StringShape;
+    isStringLiteral(): this is StringLiteralShape;
+    isNumber(): this is NumberShape;
+    isBoolean(): this is BooleanShape;
+    isNoOp(): this is NoOpShape;
+    isUnresolved(): this is UnresolvedShape;
+    isUndefined(): this is UndefinedShape;
+    isDefined(): this is this;
+    isArray(): this is ArrayShape;
+    isObject(): this is ObjectShape;
+    isRecord(): this is Record;
+    isRecordId(): this is RecordId;
+    is<const T extends [Shape, Shape, ...Shape[]]>(shapeClasses: {
+        [I in keyof T]: ShapeClass<T[I]>;
+    }, failureMessage?: string): this is T[number];
+    is<const S extends Shape>(shapeClass: ShapeClass<S>, failureMessage?: string): this is S;
+    ifResolvable(): ResolvableShape | undefined;
+    ifIdentifier(): IdentifierShape | undefined;
+    ifString(): StringShape | undefined;
+    ifStringLiteral(): StringLiteralShape | undefined;
+    ifNumber(): NumberShape | undefined;
+    ifBoolean(): BooleanShape | undefined;
+    ifUnresolved(): UnresolvedShape | undefined;
+    ifUndefined(): UndefinedShape | undefined;
+    ifDefined(): this | undefined;
+    ifArray(): ArrayShape | undefined;
+    ifObject(): ObjectShape | undefined;
+    ifRecord(): Record | undefined;
+    ifRecordId(): RecordId | undefined;
+    if<const T extends [Shape, Shape, ...Shape[]]>(shapeClasses: {
+        [I in keyof T]: ShapeClass<T[I]>;
+    }, failureMessage?: string): T[number] | undefined;
+    if<const S extends Shape>(shapeClass: ShapeClass<S>, failureMessage?: string): S | undefined;
+    asResolvable(failureMessage?: string): ResolvableShape;
+    asIdentifier(failureMessage?: string): IdentifierShape;
+    asString(failureMessage?: string): StringShape;
+    asStringLiteral(failureMessage?: string): StringLiteralShape;
+    asNumber(failureMessage?: string): NumberShape;
+    asBoolean(failureMessage?: string): BooleanShape;
+    asUnresolved(failureMessage?: string): UnresolvedShape;
+    asUndefined(failureMessage?: string): UndefinedShape;
+    asArray(failureMessage?: string): ArrayShape;
+    asObject(failureMessage?: string): ObjectShape;
+    asRecord(failureMessage?: string): Record;
+    asRecordId(failureMessage?: string): RecordId;
+    as<const T extends [Shape, Shape, ...Shape[]]>(shapeClasses: {
+        [I in keyof T]: ShapeClass<T[I]>;
+    }, failureMessage?: string): T[number];
+    as<const S extends Shape>(shapeClass: ShapeClass<S>, failureMessage?: string): S;
+    toString(): StringShape;
+    toNumber(): NumberShape;
+    toBoolean(): BooleanShape;
+    toRecordId(): RecordId;
+    getKind(): string;
+    getDescription(): string;
+    getCode(): string;
+}
+export declare class NoOpShape extends Shape<never> {
+    constructor(source: Source);
+    getValue(): never;
+}
+export declare class UnresolvedShape extends Shape<symbol> {
+    static readonly CODE = "Now.UNRESOLVED";
+    static readonly VALUE: unique symbol;
+    getValue(): symbol;
+    getCode(): string;
+}
+export declare class UndefinedShape extends Shape<undefined> {
+    constructor({ source }: {
+        source: Source;
+    });
+    getValue(): undefined;
+    equals(other: unknown): boolean;
+    toString(): StringShape;
+}
+export declare class DeletedShape extends UndefinedShape {
+}
+export declare abstract class ResolvableShape extends Shape {
+    abstract resolve(deep?: boolean): Shape;
+    equals(other: unknown): boolean;
+    getValue(): unknown;
+    toString(): StringShape;
+    toNumber(): NumberShape;
+    toBoolean(): BooleanShape;
+    toRecordId(): RecordId;
+}
+export declare class IdentifierShape extends ResolvableShape {
+    private readonly name;
+    private readonly value;
+    constructor({ source, name, value, }: {
+        source: Source;
+        name: string;
+        value?: unknown;
+    });
+    getName(): string;
+    resolve(deep?: boolean): Shape;
+    getCode(): string;
+    equals(other: unknown): boolean;
+}
+type PropertyAccessElements = readonly [IdentifierShape, IdentifierShape, ...IdentifierShape[]];
+export declare class PropertyAccessShape extends ResolvableShape {
+    private readonly elements;
+    constructor({ source, elements }: {
+        source: Source;
+        elements: readonly [unknown, unknown, ...unknown[]];
+    });
+    getElements(): PropertyAccessElements;
+    getElement(index: number): IdentifierShape;
+    getFirstElement(): IdentifierShape;
+    getLastElement(): IdentifierShape;
+    resolve(deep?: boolean): Shape<unknown>;
+    getCode(): string;
+}
+type StringContentType = 'plain' | 'cdata';
+export declare abstract class StringShape extends Shape<string> {
+    private contentType;
+    startsWith(substring: string): boolean;
+    endsWith(substring: string): boolean;
+    includes(substring: string): boolean;
+    split(separator: string): string[];
+    isEmpty(): boolean;
+    ifNotEmpty(): StringShape | undefined;
+    replace(regex: string | RegExp, replacement: string): StringShape;
+    replaceAll(regex: string | RegExp, replacement: string): StringShape;
+    parseJson(): ObjectShape | ArrayShape;
+    withContentType(contentType: StringContentType): this;
+    getContentType(): StringContentType;
+    toBoolean(): BooleanShape;
+    static escapeSingleQuotes(str: string): string;
+    static escapeBackticks(str: string): string;
+    static escapeCdataTags(str: string): string;
+}
+export declare class StringLiteralShape extends StringShape {
+    private readonly literalText;
+    constructor({ source, literalText }: {
+        source: Source;
+        literalText: string | Shape;
+    });
+    getValue(): string;
+    getCode(): string;
+}
+type TemplateSubstitutionValue = Shape | string | boolean | number;
+export type TemplateSubstitutions = ((expression: Shape) => TemplateSubstitutionValue) | globalThis.Record<number, ((expression: Shape) => TemplateSubstitutionValue) | TemplateSubstitutionValue>;
+export declare class TemplateSpanShape extends StringShape {
+    private readonly literalText;
+    private readonly expression;
+    constructor({ source, literalText, expression, }: {
+        source: Source;
+        literalText: string | Shape;
+        expression: Shape;
+    });
+    getLiteralText(): string;
+    getExpression(): Shape;
+    getValue(substitution?: ((expression: Shape) => TemplateSubstitutionValue) | TemplateSubstitutionValue): string;
+    getCode(): string;
+}
+export declare class TemplateExpressionShape extends StringShape {
+    private readonly literalText;
+    private readonly spans;
+    constructor({ source, literalText, spans, }: {
+        source: Source;
+        literalText: string | Shape;
+        spans?: TemplateSpanShape[];
+    });
+    getLiteralText(): string;
+    hasSubstitution(): boolean;
+    getSpans(): TemplateSpanShape[];
+    getValue(substitutions?: TemplateSubstitutions): string;
+    getCode(): string;
+}
+export declare class TaggedTemplateExpressionShape extends StringShape {
+    private readonly tag;
+    private readonly template;
+    constructor({ source, tag, template }: {
+        source: Source;
+        tag: string | Shape;
+        template: Shape;
+    });
+    getTag(): string;
+    getTemplate(): TemplateExpressionShape;
+    getValue(substitutions?: TemplateSubstitutions): string;
+    getCode(): string;
+}
+export declare class NumberShape extends Shape<number> {
+    private readonly value;
+    constructor({ source, value }: {
+        source: Source;
+        value: number;
+    });
+    getValue(): number;
+}
+export declare class BooleanShape extends Shape<boolean> {
+    private readonly value;
+    constructor({ source, value }: {
+        source: Source;
+        value: boolean;
+    });
+    getValue(): boolean;
+}
+export declare class ArrayShape extends Shape<unknown[]> {
+    private readonly elements;
+    constructor({ source, elements }: {
+        source: Source;
+        elements: unknown[];
+    });
+    getValue(): unknown[];
+    getElements(resolve?: boolean): Shape[];
+    getElement(index: number, resolve?: boolean): Shape;
+    hasElement(index: number): boolean;
+    map<T>(mapFunction: (element: Shape) => T, resolve?: boolean): T[];
+    equals(other: unknown): boolean;
+    static from(source: Source, value: unknown): ArrayShape;
+    getCode(): string;
+}
+declare const MERGE: unique symbol;
+declare class Transform {
+    private readonly shape;
+    private readonly resolve;
+    private readonly _from;
+    private readonly _map;
+    private readonly _def;
+    private readonly _coerce;
+    constructor(shape: ObjectShape, resolve?: boolean, _from?: [string, ...string[]] | undefined, _map?: ((...from: Shape[]) => unknown) | undefined, _def?: unknown, _coerce?: 'string' | 'number' | 'boolean' | 'cdata' | undefined);
+    _(to: string | typeof MERGE): {
+        def: unknown;
+        val: unknown;
+    };
+    from(...properties: [string, ...string[]]): Transform;
+    map(mapFunction: (...from: Shape[]) => unknown): Transform;
+    val(value: unknown): Transform;
+    def(value: unknown): Transform;
+    toCdata(): Transform;
+    toString(): Transform;
+    toNumber(): Transform;
+    toBoolean(): Transform;
+}
+type ObjectPropertyOptions = {
+    nonDefaultsOnly?: boolean;
+    resolve?: boolean;
+};
+export declare class ObjectShape extends Shape<globalThis.Record<string, unknown>> {
+    protected readonly setProperties: globalThis.Record<string, Shape>;
+    private defaultProperties;
+    private aliasedKeys;
+    constructor({ source, properties }: {
+        source: Source;
+        properties: NonNullable<object>;
+    });
+    withAliasedKeys(aliasedKeys: globalThis.Record<string, string[]>): this;
+    getAliasedKeys(): globalThis.Record<string, string[]>;
+    findAliasUsed(key: string): string | undefined;
+    getAliases(key: string): string[];
+    properties({ nonDefaultsOnly, resolve, }?: ObjectPropertyOptions): globalThis.Record<string, Shape>;
+    getValue(nonDefaultsOnly?: boolean): globalThis.Record<string, unknown>;
+    get(propertyOrPath: string | [string, ...string[]], resolve?: boolean): Shape;
+    getDefault(property: string): Shape;
+    keys(nonDefaultsOnly?: boolean): string[];
+    values(options?: ObjectPropertyOptions): Shape[];
+    entries(options?: ObjectPropertyOptions): [string, Shape][];
+    has(property: string): boolean;
+    omit(properties: string | [string, ...string[]], options?: ObjectPropertyOptions): globalThis.Record<string, Shape>;
+    pick(properties: string | [string, ...string[]], options?: ObjectPropertyOptions): globalThis.Record<string, Shape>;
+    private setDefaults;
+    transform(schema: (utils: {
+        $: Transform;
+        merge: typeof MERGE;
+    }) => {
+        [P in string | typeof MERGE]?: Transform;
+    }, resolve?: boolean): ObjectShape;
+    merge(other: NonNullable<object>): ObjectShape;
+    equals(other: unknown): boolean;
+    getCode(): string;
+    static quotePropertyNameIfNeeded(name: string): string;
+}
+export declare class CallExpressionShape extends Shape {
+    private readonly callee;
+    private readonly args;
+    constructor({ source, callee, args }: {
+        source: Source;
+        callee: string;
+        args: unknown[];
+    });
+    getCallee(): string;
+    getArguments(resolve?: boolean): Shape[];
+    getArgument(index: number, resolve?: boolean): Shape;
+    hasArgument(index: number): boolean;
+    getDescription(): string;
+    getCode(): string;
+}
+export declare class SourceFileShape extends StringShape {
+    private readonly path;
+    private readonly content;
+    constructor({ file }: {
+        file: ts.SourceFile;
+    });
+    getPath(): string;
+    getBaseName(): string;
+    getExtension(): string;
+    getContent(): string;
+    getSource(): ts.SourceFile;
+    getValue(): string;
+    getCode(): string;
+}
+export declare class ElementAccessExpressionShape extends Shape {
+    private readonly callee;
+    private readonly arg;
+    constructor({ source, callee, arg }: {
+        source: Source;
+        callee: string;
+        arg: unknown;
+    });
+    getCallee(): string;
+    getArg(): StringShape | NumberShape;
+}
+export declare class VariableStatementShape extends Shape {
+    private readonly variableName;
+    private readonly initializer;
+    private readonly _isExported;
+    constructor({ source, variableName, initializer, isExported, }: {
+        source: Source;
+        variableName: IdentifierShape | string;
+        initializer: unknown;
+        isExported?: boolean;
+    });
+    getVariableName(): IdentifierShape;
+    getInitializer(): Shape;
+    isExported(): boolean;
+    getCode(): string;
+}
+export declare function getInstallCategory(source: Source, table: string): InstallCategory;
+export type Action = 'INSERT_OR_UPDATE' | 'UPDATE' | 'DELETE' | 'delete_multiple';
+export declare class Record extends ObjectShape {
+    private readonly id;
+    private readonly related;
+    private readonly action;
+    private readonly installCategory;
+    constructor({ source, id, properties, action, installCategory, }: {
+        source: Source;
+        id: RecordId;
+        properties: NonNullable<object>;
+        action?: Action;
+        installCategory?: InstallCategory;
+    });
+    static isDeleteAction(action: Action): boolean;
+    getId(): RecordId;
+    getInstallCategory(): InstallCategory;
+    getTable(): string;
+    getAction(): Action;
+    isDeleted(): boolean;
+    getUpdateName(): string;
+    with(...related: Record[]): this;
+    flat(): Record[];
+    getCount(): number;
+    merge(other: NonNullable<object>): Record;
+    equals(other: unknown): boolean;
+    /**
+     * Useful when you need to know if this record is equal to another not
+     * just in terms of its identity but also its data.
+     */
+    strictEquals(other: unknown): boolean;
+    setCreator(creator: Plugin | undefined, overwrite?: boolean): this;
+    toRecordId(): RecordId;
+    toString(): StringShape;
+}
+export type CoalesceKeys = globalThis.Record<string, string | RecordId>;
+export type ResolvedCoalesceKeys = globalThis.Record<string, string>;
+export declare class RecordId extends StringShape {
+    private readonly table;
+    private readonly guid;
+    private readonly keys;
+    private readonly nowIdKey;
+    constructor({ source, table, guid, keys: rawKeys, nowIdKey, }: {
+        source: Source;
+        table: string;
+        guid: string | (() => string);
+        keys?: CoalesceKeys | ObjectShape | undefined;
+        nowIdKey?: string | number | undefined;
+    });
+    getTable(): string;
+    getGuidProducer(): string | (() => string);
+    getNowIdKey(): string | number | undefined;
+    getKeys(): CoalesceKeys | undefined;
+    /**
+     * Similar to `getKeys`, but resolves any nested record IDs to their GUID values
+     */
+    resolveKeys(): ResolvedCoalesceKeys | undefined;
+    getKey(key: string): string | RecordId | undefined;
+    getPrimaryKey(): string;
+    hasPrimaryKey(): boolean;
+    getUpdateName(): string;
+    getValue(): string;
+    equals(other: unknown): boolean;
+    getCode(): string;
+}
+export {};