appium-novawindows2-driver 0.1.1

package/lib/driver.ts

@@ -0,0 +1,247 @@
+import { ChildProcessWithoutNullStreams } from 'node:child_process';
+import { BaseDriver, W3C_ELEMENT_KEY, errors } from '@appium/base-driver';
+import { system } from 'appium/support';
+import commands from './commands';
+import {
+    UI_AUTOMATION_DRIVER_CONSTRAINTS,
+    NovaWindowsDriverConstraints
+} from './constraints';
+import {
+    assertSupportedEasingFunction
+} from './util';
+import {
+    Condition,
+    PropertyCondition,
+    AutomationElement,
+    FoundAutomationElement,
+    TreeScope,
+    Property,
+    convertStringToCondition,
+    PSString,
+    PSControlType,
+    PSInt32Array,
+} from './powershell';
+import { xpathToElIdOrIds } from './xpath';
+import { setDpiAwareness } from './winapi/user32';
+
+import type {
+    DefaultCreateSessionResult,
+    DriverData,
+    Element,
+    InitialOpts,
+    StringRecord,
+    W3CDriverCaps
+} from '@appium/types';
+
+type W3CNovaWindowsDriverCaps = W3CDriverCaps<NovaWindowsDriverConstraints>;
+type DefaultWindowsCreateSessionResult = DefaultCreateSessionResult<NovaWindowsDriverConstraints>;
+
+type KeyboardState = {
+    pressed: Set<string>,
+    shift: boolean,
+    ctrl: boolean,
+    meta: boolean,
+    alt: boolean,
+}
+
+const LOCATION_STRATEGIES = Object.freeze([
+    'id',
+    'name',
+    'xpath',
+    'tag name',
+    'class name',
+    'accessibility id',
+    '-windows uiautomation',
+] as const);
+
+export class NovaWindowsDriver extends BaseDriver<NovaWindowsDriverConstraints, StringRecord> {
+    isPowerShellSessionStarted: boolean = false;
+    powerShell?: ChildProcessWithoutNullStreams;
+    powerShellStdOut: string = '';
+    powerShellStdErr: string = '';
+    keyboardState: KeyboardState = {
+        pressed: new Set(),
+        alt: false,
+        ctrl: false,
+        meta: false,
+        shift: false,
+    };
+
+    constructor(opts: InitialOpts = {} as InitialOpts, shouldValidateCaps = true) {
+        super(opts, shouldValidateCaps);
+
+        this.locatorStrategies = [...LOCATION_STRATEGIES];
+        this.desiredCapConstraints = UI_AUTOMATION_DRIVER_CONSTRAINTS;
+
+        for (const key in commands) { // TODO: create a decorator that will do that for the class
+            NovaWindowsDriver.prototype[key] = commands[key].bind(this);
+        }
+    }
+
+    override async findElement(strategy: string, selector: string): Promise<Element> {
+        [strategy, selector] = this.processSelector(strategy, selector);
+        return super.findElement(strategy, selector);
+    }
+
+    override async findElements(strategy: string, selector: string): Promise<Element[]> {
+        [strategy, selector] = this.processSelector(strategy, selector);
+        return super.findElements(strategy, selector);
+    }
+
+    override async findElementFromElement(strategy: string, selector: string, elementId: string): Promise<Element> {
+        [strategy, selector] = this.processSelector(strategy, selector);
+        return super.findElementFromElement(strategy, selector, elementId);
+    }
+
+    override async findElementsFromElement(strategy: string, selector: string, elementId: string): Promise<Element[]> {
+        [strategy, selector] = this.processSelector(strategy, selector);
+        return super.findElementsFromElement(strategy, selector, elementId);
+    }
+
+    override async findElOrEls(strategy: typeof LOCATION_STRATEGIES[number], selector: string, mult: true, context?: string): Promise<Element[]>;
+    override async findElOrEls(strategy: typeof LOCATION_STRATEGIES[number], selector: string, mult: false, context?: string): Promise<Element>;
+    override async findElOrEls(strategy: typeof LOCATION_STRATEGIES[number], selector: string, mult: boolean, context?: string): Promise<Element | Element[]> {
+        let condition: Condition;
+        switch (strategy) {
+            case 'id':
+                condition = new PropertyCondition(Property.RUNTIME_ID, new PSInt32Array(selector.split('.').map(Number)));
+                break;
+            case 'tag name':
+                condition = new PropertyCondition(Property.CONTROL_TYPE, new PSControlType(selector));
+                break;
+            case 'accessibility id':
+                condition = new PropertyCondition(Property.AUTOMATION_ID, new PSString(selector));
+                break;
+            case 'name':
+                condition = new PropertyCondition(Property.NAME, new PSString(selector));
+                break;
+            case 'class name':
+                condition = new PropertyCondition(Property.CLASS_NAME, new PSString(selector));
+                break;
+            case '-windows uiautomation':
+                condition = convertStringToCondition(selector);
+                break;
+            case 'xpath':
+                return await xpathToElIdOrIds(selector, mult, context, this.sendPowerShellCommand.bind(this));
+            default:
+                throw new errors.InvalidArgumentError(`Invalid find strategy ${strategy}`);
+        }
+
+        const searchContext = context ? new FoundAutomationElement(context) : AutomationElement.automationRoot;
+
+        if (mult) {
+            const result = await this.sendPowerShellCommand(searchContext.findAll(TreeScope.DESCENDANTS, condition).buildCommand());
+            const elIds = result.split('\n').map((elId) => elId.trim()).filter(Boolean);
+            return elIds.filter(Boolean).map((elId) => ({ [W3C_ELEMENT_KEY]: elId }));
+        }
+
+        const result = await this.sendPowerShellCommand(searchContext.findFirst(TreeScope.DESCENDANTS, condition).buildCommand());
+        const elId = result.trim();
+
+        if (!elId) {
+            throw new errors.NoSuchElementError();
+        }
+
+        return { [W3C_ELEMENT_KEY]: elId };
+    }
+
+    override async createSession(
+        jwpCaps: W3CNovaWindowsDriverCaps,
+        reqCaps?: W3CNovaWindowsDriverCaps,
+        w3cCaps?: W3CNovaWindowsDriverCaps,
+        driverData?: DriverData[]
+    ): Promise<DefaultWindowsCreateSessionResult> {
+        if (!system.isWindows()) {
+            this.log.errorWithException('Windows UI Automation tests only run on Windows.');
+        }
+
+        if (typeof w3cCaps?.alwaysMatch?.['appium:appTopLevelWindow'] === 'number') {
+            w3cCaps.alwaysMatch['appium:appTopLevelWindow'] = String(w3cCaps.alwaysMatch['appium:appTopLevelWindow']);
+        }
+
+        if (typeof w3cCaps?.firstMatch?.some['appium:appTopLevelWindow'] === 'number') {
+            w3cCaps.firstMatch['appium:appTopLevelWindow'] = w3cCaps.firstMatch['appium:appTopLevelWindow'].map(String);
+        }
+
+        try {
+            this.log.debug('Creating NovaWindows driver session...');
+            const [sessionId, caps] = await super.createSession(jwpCaps, reqCaps, w3cCaps, driverData);
+            if (caps.smoothPointerMove) {
+                assertSupportedEasingFunction(caps.smoothPointerMove);
+            }
+            if (caps.app && caps.appTopLevelWindow) {
+                throw new errors.InvalidArgumentError('Invalid capabilities. Specify either app or appTopLevelWindow.');
+            }
+            if (this.caps.shouldCloseApp === undefined) {
+                this.caps.shouldCloseApp = true; // set default value
+            }
+
+            await this.startPowerShellSession();
+
+            if (this.caps.prerun) {
+                this.log.info('Executing prerun PowerShell script...');
+                await this.executePowerShellScript(this.caps.prerun as Exclude<Parameters<typeof commands['executePowerShellScript']>[0], string>);
+            }
+
+            setDpiAwareness();
+            this.log.debug(`Started session ${sessionId}.`);
+            return [sessionId, caps];
+        } catch (e) {
+            await this.deleteSession();
+            throw e;
+        }
+    }
+
+    override async deleteSession(sessionId?: string | null | undefined): Promise<void> {
+        this.log.debug('Deleting NovaWindows driver session...');
+
+        if (this.caps.shouldCloseApp && this.caps.app && this.caps.app.toLowerCase() !== 'root') {
+            try {
+                const result = await this.sendPowerShellCommand(AutomationElement.automationRoot.buildCommand());
+                const elementId = result.split('\n').map((id) => id.trim()).filter(Boolean)[0];
+                if (elementId) {
+                    await this.sendPowerShellCommand(new FoundAutomationElement(elementId).buildCloseCommand());
+                }
+            } catch {
+                // noop
+            }
+        } // change to close the whole process, not only the window
+        await this.terminatePowerShellSession();
+
+        if (this.caps.postrun) {
+            this.log.info('Executing postrun PowerShell script...');
+            await this.executePowerShellScript(this.caps.postrun as Exclude<Parameters<typeof commands['executePowerShellScript']>[0], string>);
+        }
+
+        await super.deleteSession(sessionId);
+    }
+
+    private processSelector(strategy: string, selector: string): [string, string] {
+        if (strategy !== 'css selector') {
+            return [strategy, selector];
+        }
+
+        this.log.warn('Warning: Use Appium mobile selectors instead of Selenium By, since most of them are based on CSS.');
+        const digitRegex = /\\3(\d) /;
+
+        if (selector.startsWith('.')) {
+            selector = selector.substring(1).replace(digitRegex, '$1');
+            strategy = 'class name';
+            return [strategy, selector];
+        }
+
+        if (selector.startsWith('#')) {
+            selector = selector.substring(1).replace(digitRegex, '$1');
+            strategy = 'id';
+            return [strategy, selector];
+        }
+
+        if (selector.startsWith('*[name')) {
+            selector = selector.substring(selector.indexOf('"') + 1, selector.lastIndexOf('"')).replace(digitRegex, '$1');
+            strategy = 'name';
+            return [strategy, selector];
+        }
+
+        return [strategy, selector];
+    }
+}

package/lib/enums.ts

@@ -0,0 +1,96 @@
+type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N
+    ? Acc[number]
+    : Enumerate<N, [...Acc, Acc['length']]>
+
+type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>> | T
+
+type AllFlagsValue<N extends number, A extends any[] = []> = [N] extends [Partial<A>['length']] ? A['length'] : UnionFlags<N, [0, ...A, ...A]>;
+type UnionFlags<N extends number, A extends any[] = []> = IntRange<0, AllFlagsValue<N, A>>;
+
+export type Enum<T> = T[keyof T];
+export type FlagsEnum<T> = Enum<T> extends number ? UnionFlags<Enum<T>> : never;
+
+export const Key = Object.freeze({
+    NULL: '\uE000',
+    CANCEL: '\uE001',
+    HELP: '\uE002',
+    BACKSPACE: '\uE003',
+    TAB: '\uE004',
+    CLEAR: '\uE005',
+    RETURN: '\uE006',
+    ENTER: '\uE007',
+    SHIFT: '\uE008',
+    CONTROL: '\uE009',
+    ALT: '\uE00A',
+    PAUSE: '\uE00B',
+    ESCAPE: '\uE00C',
+    SPACE: '\uE00D',
+    PAGE_UP: '\uE00E',
+    PAGE_DOWN: '\uE00F',
+    END: '\uE010',
+    HOME: '\uE011',
+    LEFT: '\uE012',
+    UP: '\uE013',
+    RIGHT: '\uE014',
+    DOWN: '\uE015',
+    INSERT: '\uE016',
+    DELETE: '\uE017',
+    SEMICOLON: '\uE018',
+    EQUALS: '\uE019',
+    NUMPAD0: '\uE01A',
+    NUMPAD1: '\uE01B',
+    NUMPAD2: '\uE01C',
+    NUMPAD3: '\uE01D',
+    NUMPAD4: '\uE01E',
+    NUMPAD5: '\uE01F',
+    NUMPAD6: '\uE020',
+    NUMPAD7: '\uE021',
+    NUMPAD8: '\uE022',
+    NUMPAD9: '\uE023',
+    MULTIPLY: '\uE024',
+    ADD: '\uE025',
+    SEPARATOR: '\uE026',
+    SUBTRACT: '\uE027',
+    DECIMAL: '\uE028',
+    DIVIDE: '\uE029',
+    F1: '\uE031',
+    F2: '\uE032',
+    F3: '\uE033',
+    F4: '\uE034',
+    F5: '\uE035',
+    F6: '\uE036',
+    F7: '\uE037',
+    F8: '\uE038',
+    F9: '\uE039',
+    F10: '\uE03A',
+    F11: '\uE03B',
+    F12: '\uE03C',
+    META: '\uE03D',
+    ZENKAKUHANKAKU: '\uE040',
+    R_SHIFT: '\uE050',
+    R_CONTROL: '\uE051',
+    R_ALT: '\uE052',
+    R_META: '\uE053',
+    R_PAGEUP: '\uE054',
+    R_PAGEDOWN: '\uE055',
+    R_END: '\uE056',
+    R_HOME: '\uE057',
+    R_ARROWLEFT: '\uE058',
+    R_ARROWUP: '\uE059',
+    R_ARROWRIGHT: '\uE05A',
+    R_ARROWDOWN: '\uE05B',
+    R_INSERT: '\uE05C',
+    R_DELETE: '\uE05D',
+} as const);
+
+export type Key = Enum<typeof Key>;
+
+export const ClickType = Object.freeze({
+    LEFT: 'left',
+    MIDDLE: 'middle',
+    RIGHT: 'right',
+    BACK: 'back',
+    FORWARD: 'forward'
+});
+
+export type ClickType = Enum<typeof ClickType>;

package/lib/powershell/common.ts

@@ -0,0 +1,137 @@
+import { W3C_ELEMENT_KEY, errors } from '@appium/base-driver';
+import { Element, Position, Rect } from '@appium/types';
+import {
+    AutomationHeadingLevel,
+    ControlType,
+    ExtraControlType,
+    OrientationType,
+} from './types';
+import { FoundAutomationElement } from './elements';
+import { PSObject } from './core';
+
+export class PSString extends PSObject {
+    constructor(value: string) {
+        const escapedUnicodeString = value.split('')
+            .map((c) => /* ps1 */ `$([char]0x${c.charCodeAt(0).toString(16).padStart(4, '0')})`)
+            .join('');
+        super(`"${escapedUnicodeString}"`);
+    }
+}
+
+export class PSBoolean extends PSObject {
+    constructor(value: boolean) {
+        if (typeof value !== 'boolean') {
+            throw new errors.InvalidArgumentError(`PSBoolean accepts only boolean in the constructor, but got '${value}'.`);
+        }
+        super(value ? /* ps1 */ `$true` : /* ps1 */ `$false`);
+    }
+}
+
+export class PSInt32 extends PSObject {
+    constructor(value: number) {
+        if (!Number.isInteger(value)) {
+            throw new errors.InvalidArgumentError(`PSInt32 accepts only integer values in the constructor, but got '${value}'.`);
+        }
+        super(value.toString());
+    }
+}
+
+export class PSInt32Array extends PSObject {
+    constructor(value: number[]) {
+        if (!(Array.isArray(value) && value.every(Number.isInteger))) {
+            throw new errors.InvalidArgumentError(`PSInt32Array accepts only array of integers in the constructor, but got ${Array.isArray(value) ? `[${value}]` : `'${value}'`}.`);
+        }
+
+        super(/* ps1 */ `[int32[]] @(${value.join(', ')})`);
+    }
+}
+
+export class PSAutomationHeadingLevel extends PSObject {
+    readonly originalValue: string;
+
+    constructor(value: string) {
+        if (!Object.values(AutomationHeadingLevel).includes(value.toLowerCase() as AutomationHeadingLevel)) {
+            throw new errors.InvalidArgumentError(`PSAutomationHeadingLevel accepts valid AutomationHeadingLevel enum value in the constructor, but got '${value}'.`);
+        }
+
+        super(/* ps1 */ `[AutomationHeadingLevel]::${value}`);
+        this.originalValue = value;
+    }
+}
+
+export class PSOrientationType extends PSObject {
+    readonly originalValue: string;
+
+    constructor(value: string) {
+        if (!Object.values(OrientationType).includes(value.toLowerCase() as OrientationType)) {
+            throw new errors.InvalidArgumentError(`PSOrientationType accepts valid OrientationType enum value in the constructor, but got '${value}'.`);
+        }
+
+        super(/* ps1 */ `[OrientationType]::${value}`);
+        this.originalValue = value;
+    }
+}
+
+export class PSControlType extends PSObject {
+    constructor(value: string) {
+        if (![...Object.values(ControlType), ...Object.values(ExtraControlType)].includes(value.toLowerCase() as ControlType)) {
+            throw new errors.InvalidArgumentError(`PSControlType accepts a valid ControlType in the constructor, but got '${value}'.`);
+        }
+
+        if (ExtraControlType.SEMANTIC_ZOOM === value.toLowerCase()) {
+            super('semantic zoom');
+            return;
+        }
+
+        if (ExtraControlType.APP_BAR === value.toLowerCase()) {
+            super('app bar');
+            return;
+        }
+
+        super(/* ps1 */ `[ControlType]::${value}`);
+    }
+}
+
+export class PSPoint extends PSObject {
+    constructor(value: Position) {
+        const requiredFields = ['x', 'y'];
+        if (!(Object.keys(value).every(requiredFields.includes) && typeof value.x === 'number' && typeof value.y === 'number')) {
+            throw new errors.InvalidArgumentError('PSPoint accepts a Position object { x: number, y: number } in the constructor.');
+        }
+
+        super(/* ps1 */ `[System.Windows.Point]::new(${value.x}, ${value.y})`);
+    }
+}
+
+export class PSRect extends PSObject {
+    constructor(value: Rect) {
+        const requiredFields = ['x', 'y', 'width', 'height'];
+        if (!(Object.keys(value).every(requiredFields.includes) && typeof value.x === 'number' && typeof value.y === 'number' && typeof value.width === 'number' && typeof value.height === 'number')) {
+            throw new errors.InvalidArgumentError('PSRect accepts a Rect object { x: number, y: number, width: number, height: number } in the constructor.');
+        }
+
+        super(/* ps1 */ `[System.Windows.Rect]::new(${value.x}, ${value.y}, ${value.width}, ${value.height})`);
+    }
+}
+
+export class PSAutomationElement extends PSObject {
+    constructor(value: Element) {
+        if (!value[W3C_ELEMENT_KEY]) {
+            throw new errors.InvalidArgumentError('PSAutomationElement accepts a valid Appium Element in the constructor.');
+        }
+
+        super(new FoundAutomationElement(value[W3C_ELEMENT_KEY]).toString());
+    }
+}
+
+export class PSCultureInfo extends PSObject {
+    constructor(name: string, useUserOverride?: boolean)
+    constructor(culture: number, useUserOverride?: boolean)
+    constructor(nameOrCulture: string | number, useUserOverride?: boolean) {
+        if (typeof nameOrCulture !== 'string' || (typeof nameOrCulture === 'number' && nameOrCulture < 0)) {
+            throw new errors.InvalidArgumentError('PSCultureInfo accepts a string or positive integer value in the constructor.');
+        }
+
+        super(/* ps1 */ `[System.Globalization.CultureInfo]::new(${typeof nameOrCulture === 'string' ? `'${nameOrCulture}'` : nameOrCulture}${useUserOverride !== undefined ? `$${useUserOverride}` : ''})`);
+    }
+}

package/lib/powershell/conditions.ts

@@ -0,0 +1,169 @@
+import { errors } from '@appium/base-driver';
+import { $ } from '../util';
+import { PSObject } from './core';
+import {
+    Property,
+    CultureInfoProperty,
+    AutomationHeadingLevelProperty,
+    PointProperty,
+    ControlTypeProperty,
+    AutomationElementProperty,
+    OrientationTypeProperty,
+    RectProperty,
+    Int32Property,
+    Int32ArrayProperty,
+    StringProperty,
+    BooleanProperty,
+    OrientationType,
+    AutomationHeadingLevel,
+} from './types';
+import {
+    PSAutomationElement,
+    PSAutomationHeadingLevel,
+    PSBoolean,
+    PSControlType,
+    PSCultureInfo,
+    PSInt32,
+    PSInt32Array,
+    PSOrientationType,
+    PSPoint,
+    PSRect,
+    PSString,
+} from './common';
+
+const PROPERTY_CONDITION = $ /* ps1 */ `[PropertyCondition]::new([AutomationElement]::${0}Property, ${1})`;
+const AND_CONDITION = $ /* ps1 */ `[AndCondition]::new(${0})`;
+const OR_CONDITION = $ /* ps1 */ `[OrCondition]::new(${0})`;
+const NOT_CONDITION = $ /* ps1 */ `[NotCondition]::new(${0})`;
+const TRUE_CONDITION = /* ps1 */ `[Condition]::TrueCondition`;
+const FALSE_CONDITION = /* ps1 */ `[Condition]::FalseCondition`;
+
+export abstract class Condition extends PSObject {
+    constructor(command: string) {
+        super(command);
+    }
+}
+
+export class PropertyCondition extends Condition {
+    constructor(property: Property, value: PSObject) {
+        property = property.toLowerCase().endsWith('property') ? property.slice(0, property.length - 8) as Property : property;
+
+        if (Object.values(BooleanProperty).includes(property as BooleanProperty)) {
+            assertPSObjectType(value, PSBoolean);
+        }
+
+        if (Object.values(Int32Property).includes(property as Int32Property)) {
+            assertPSObjectType(value, PSInt32);
+        }
+
+        if (Object.values(StringProperty).includes(property as StringProperty)) {
+            assertPSObjectType(value, PSString);
+        }
+
+        if (Object.values(Int32ArrayProperty).includes(property as Int32ArrayProperty)) {
+            assertPSObjectType(value, PSInt32Array);
+        }
+
+        if (Object.values(PointProperty).includes(property as PointProperty)) {
+            assertPSObjectType(value, PSPoint);
+        }
+
+        if (Object.values(RectProperty).includes(property as RectProperty)) {
+            assertPSObjectType(value, PSRect);
+        }
+
+        if (Object.values(ControlTypeProperty).includes(property as ControlTypeProperty)) {
+            assertPSObjectType(value, PSControlType);
+        }
+
+        if (Object.values(AutomationElementProperty).includes(property as AutomationElementProperty)) {
+            assertPSObjectType(value, PSAutomationElement);
+        }
+
+        if (Object.values(OrientationTypeProperty).includes(property as OrientationTypeProperty)) {
+            try {
+                assertPSObjectType(value, PSOrientationType);
+            } catch (e) {
+                if (value instanceof PSAutomationHeadingLevel && value.originalValue.toLowerCase() === AutomationHeadingLevel.NONE) {
+                    value = new PSOrientationType(OrientationType.NONE);
+                } else if (!(value instanceof PSInt32) || Number(value.toString()) < 0 || Number(value.toString()) >= Object.keys(AutomationHeadingLevel).length) {
+                    throw e;
+                }
+            }
+        }
+
+        if (Object.values(AutomationHeadingLevelProperty).includes(property as AutomationHeadingLevelProperty)) {
+            try {
+                assertPSObjectType(value, PSAutomationHeadingLevel);
+            } catch (e) {
+                if (value instanceof PSOrientationType && value.originalValue.toLowerCase() === OrientationType.NONE) {
+                    value = new PSAutomationHeadingLevel(AutomationHeadingLevel.NONE);
+                } else if (!(value instanceof PSInt32) || Number(value.toString()) < 0 || Number(value.toString()) >= Object.keys(OrientationType).length) {
+                    throw e;
+                }
+            }
+        }
+
+        if (Object.values(CultureInfoProperty).includes(property as CultureInfoProperty)) {
+            assertPSObjectType(value, PSCultureInfo);
+        }
+
+        super(PROPERTY_CONDITION.format(property, value));
+    }
+}
+
+export class AndCondition extends Condition {
+    constructor(...conditions: Condition[]) {
+        if (!conditions.every((arg) => arg instanceof Condition)) {
+            throw new errors.InvalidArgumentError(`AndCondition expects Conditions as args but received ${(conditions.find((x) => !(x instanceof Condition)) as unknown)?.constructor.name}.`);
+        }
+
+        if (conditions.length < 2) {
+            throw new errors.InvalidArgumentError(`AndCondition must have at least 2 conditions, but received ${conditions.length}.`);
+        }
+
+        super(AND_CONDITION.format(conditions.join(', ')));
+    }
+}
+
+export class OrCondition extends Condition {
+    constructor(...conditions: Condition[]) {
+        if (!conditions.every((arg) => arg instanceof Condition)) {
+            throw new errors.InvalidArgumentError(`OrCondition expects Conditions as args but received ${(conditions.find((x) => !(x instanceof Condition)) as unknown)?.constructor.name}.`);
+        }
+
+        if (conditions.length < 2) {
+            throw new errors.InvalidArgumentError(`OrCondition must have at least 2 conditions, but received ${conditions.length}.`);
+        }
+
+        super(OR_CONDITION.format(conditions.join(', ')));
+    }
+}
+
+export class NotCondition extends Condition {
+    constructor(condition: Condition) {
+        if (!(condition instanceof Condition)) {
+            throw new errors.InvalidArgumentError(`AndCondition expects Conditions as args but received ${(condition as unknown)?.constructor.name}.`);
+        }
+
+        super(NOT_CONDITION.format(condition));
+    }
+}
+
+export class TrueCondition extends Condition {
+    constructor() {
+        super(TRUE_CONDITION);
+    }
+}
+
+export class FalseCondition extends Condition {
+    constructor() {
+        super(FALSE_CONDITION);
+    }
+}
+
+function assertPSObjectType(obj: PSObject, type: new (...args: any[]) => PSObject) {
+    if (!(obj instanceof type)) {
+        throw new errors.InvalidArgumentError(`Property expected type ${type.name} but got ${(obj as object)?.constructor.name}.`);
+    }
+}