@api-client/core 0.9.4 → 0.9.6

package/src/models/http-actions/steps/assertion/EqualAssertion.ts

@@ -0,0 +1,130 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const EqualAssertionKind = 'HttpAction#EqualAssertion';
+
+/**
+ * An assertion that makes sure the input value is [strict] equal to the set value.
+ */
+export interface IEqualAssertion extends IHttpStep {
+  kind: typeof EqualAssertionKind;
+
+  /**
+   * The value to compare to.
+   * This is always a string. Use the `dataType` to determine the correct data type.
+   */
+  value?: string;
+
+  /**
+   * The data type of the value. This is a value prefixed with 
+   * `http://www.w3.org/2001/XMLSchema#` or `http://a.ml/vocabularies/shapes#`.
+   * 
+   * Examples:
+   * 
+   * - `http://www.w3.org/2001/XMLSchema#boolean`
+   * - `http://www.w3.org/2001/XMLSchema#string`
+   * - `http://www.w3.org/2001/XMLSchema#number`
+   * - `http://www.w3.org/2001/XMLSchema#integer`
+   * - `http://www.w3.org/2001/XMLSchema#long`
+   * - `http://a.ml/vocabularies/shapes#number`
+   * - `http://a.ml/vocabularies/shapes#integer`
+   * - `http://a.ml/vocabularies/shapes#double`
+   * - ...
+   * 
+   * @default `http://www.w3.org/2001/XMLSchema#string`
+   */
+  dataType?: string;
+
+  /**
+   * Whether it should check for a value and the data type.
+   */
+  strict?: boolean;
+}
+
+/**
+ * An assertion that makes sure the input value is [strict] equal to the set value.
+ */
+export class EqualAssertion extends HttpStep {
+  override kind = EqualAssertionKind;
+
+  /**
+   * The value to compare to.
+   * This is always a string. Use the `dataType` to determine the correct data type.
+   */
+  value?: string;
+
+  /**
+   * The data type of the value. This is a value prefixed with 
+   * `http://www.w3.org/2001/XMLSchema#` or `http://a.ml/vocabularies/shapes#`.
+   * 
+   * Examples:
+   * 
+   * - `http://www.w3.org/2001/XMLSchema#boolean`
+   * - `http://www.w3.org/2001/XMLSchema#string`
+   * - `http://www.w3.org/2001/XMLSchema#number`
+   * - `http://www.w3.org/2001/XMLSchema#integer`
+   * - `http://www.w3.org/2001/XMLSchema#long`
+   * - `http://a.ml/vocabularies/shapes#number`
+   * - `http://a.ml/vocabularies/shapes#integer`
+   * - `http://a.ml/vocabularies/shapes#double`
+   * - ...
+   * 
+   * @default `http://www.w3.org/2001/XMLSchema#string`
+   */
+  dataType?: string;
+
+  /**
+   * Whether it should check for a value and the data type.
+   */
+  strict?: boolean;
+
+  constructor(value: string, strict?: boolean, dataType?: string);
+
+  constructor(init: IEqualAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IEqualAssertion | string, strict?: boolean, dataType?: string) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IEqualAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: EqualAssertionKind,
+        value: valueOrInit,
+        dataType,
+        strict,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IEqualAssertion): void {
+    super.new(init);
+    this.kind = EqualAssertionKind;
+    this.value = init.value;
+    this.dataType = init.dataType;
+    this.strict = init.strict;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): IEqualAssertion {
+    const result: IEqualAssertion = {
+      ...super.toJSON(),
+      kind: EqualAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    if (this.dataType) {
+      result.dataType = this.dataType;
+    }
+    if (typeof this.strict === 'boolean') {
+      result.strict = this.strict;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/GreaterThanAssertion.ts

@@ -0,0 +1,87 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const GreaterThanAssertionKind = 'HttpAction#GreaterThanAssertion';
+
+/**
+ * An assertion that makes sure the input value is greater [or equal] to the set value.
+ */
+export interface IGreaterThanAssertion extends IHttpStep {
+  kind: typeof GreaterThanAssertionKind;
+
+  /**
+   * The value to compare to.
+   */
+  value?: number;
+
+  /**
+   * When set it treats the assertion as "greater than or equal"
+   */
+  equal?: boolean;
+}
+
+/**
+ * An assertion that makes sure the input value is greater [or equal] to the set value.
+ */
+export class GreaterThanAssertion extends HttpStep {
+  override kind = GreaterThanAssertionKind;
+
+  /**
+   * The value to compare to.
+   */
+  value?: number;
+
+  /**
+   * When set it treats the assertion as "greater than or equal"
+   */
+  equal?: boolean;
+
+  constructor(value: number, equal?: boolean);
+
+  constructor(init: IGreaterThanAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IGreaterThanAssertion | number, equal?: boolean) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IGreaterThanAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'number') {
+      this.new({
+        kind: GreaterThanAssertionKind,
+        value: valueOrInit,
+        equal,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IGreaterThanAssertion): void {
+    super.new(init);
+    this.kind = GreaterThanAssertionKind;
+    this.value = init.value;
+    if (typeof init.equal === 'boolean') {
+      this.equal = init.equal;
+    } else {
+      this.equal = undefined;
+    }
+  }
+
+  checkValidity(): boolean {
+    return typeof this.value === 'number';
+  }
+
+  override toJSON(): IGreaterThanAssertion {
+    const result: IGreaterThanAssertion = {
+      ...super.toJSON(),
+      kind: GreaterThanAssertionKind,
+    };
+    if (typeof this.value === 'number') {
+      result.value = this.value;
+    }
+    if (typeof this.equal === 'boolean') {
+      result.equal = this.equal;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/IncludesAssertion.ts

@@ -0,0 +1,68 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const IncludesAssertionKind = 'HttpAction#IncludesAssertion';
+
+/**
+ * An assertion that makes sure the input includes the set value.
+ */
+export interface IIncludesAssertion extends IHttpStep {
+  kind: typeof IncludesAssertionKind;
+
+  /**
+   * The value to search for.
+   */
+  value?: string;
+}
+
+/**
+ * An assertion that makes sure the input includes the set value.
+ */
+export class IncludesAssertion extends HttpStep {
+  override kind = IncludesAssertionKind;
+
+  /**
+   * The value to search for.
+   */
+  value?: string;
+
+  constructor(value: string);
+
+  constructor(init: IIncludesAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IIncludesAssertion | string) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IIncludesAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: IncludesAssertionKind,
+        value: valueOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IIncludesAssertion): void {
+    super.new(init);
+    this.kind = IncludesAssertionKind;
+    this.value = init.value;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): IIncludesAssertion {
+    const result: IIncludesAssertion = {
+      ...super.toJSON(),
+      kind: IncludesAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/IsEmptyAssertion.ts

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const IsEmptyAssertionKind = 'HttpAction#IsEmptyAssertion';
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export interface IIsEmptyAssertion extends IHttpStep {
+  kind: typeof IsEmptyAssertionKind;
+}
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export class IsEmptyAssertion extends HttpStep {
+  override kind = IsEmptyAssertionKind;
+
+  constructor(init?: IIsEmptyAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IIsEmptyAssertion): void {
+    super.new(init);
+    this.kind = IsEmptyAssertionKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IIsEmptyAssertion {
+    const result: IIsEmptyAssertion = {
+      ...super.toJSON(),
+      kind: IsEmptyAssertionKind,
+    };
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/IsNotEmptyAssertion.ts

@@ -0,0 +1,41 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const IsNotEmptyAssertionKind = 'HttpAction#IsNotEmptyAssertion';
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export interface IIsNotEmptyAssertion extends IHttpStep {
+  kind: typeof IsNotEmptyAssertionKind;
+}
+
+/**
+ * An assertion that makes sure the input is empty (empty array, empty string, empty object - no properties)
+ */
+export class IsNotEmptyAssertion extends HttpStep {
+  override kind = IsNotEmptyAssertionKind;
+
+  constructor(init?: IIsNotEmptyAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IIsNotEmptyAssertion): void {
+    super.new(init);
+    this.kind = IsNotEmptyAssertionKind;
+  }
+
+  checkValidity(): boolean {
+    return true;
+  }
+
+  override toJSON(): IIsNotEmptyAssertion {
+    const result: IIsNotEmptyAssertion = {
+      ...super.toJSON(),
+      kind: IsNotEmptyAssertionKind,
+    };
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/LengthOfAssertion.ts

@@ -0,0 +1,68 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const LengthOfAssertionKind = 'HttpAction#LengthOfAssertion';
+
+/**
+ * An assertion that makes sure the input has a length of the specified value.
+ */
+export interface ILengthOfAssertion extends IHttpStep {
+  kind: typeof LengthOfAssertionKind;
+
+  /**
+   * The expected size of the array.
+   */
+  value?: number;
+}
+
+/**
+ * An assertion that makes sure the input has a length of the specified value.
+ */
+export class LengthOfAssertion extends HttpStep {
+  override kind = LengthOfAssertionKind;
+
+  /**
+   * The expected size of the array.
+   */
+  value?: number;
+
+  constructor(value: number);
+
+  constructor(init: ILengthOfAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: ILengthOfAssertion | number) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as ILengthOfAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'number') {
+      this.new({
+        kind: LengthOfAssertionKind,
+        value: valueOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: ILengthOfAssertion): void {
+    super.new(init);
+    this.kind = LengthOfAssertionKind;
+    this.value = init.value;
+  }
+
+  checkValidity(): boolean {
+    return typeof this.value === 'number';
+  }
+
+  override toJSON(): ILengthOfAssertion {
+    const result: ILengthOfAssertion = {
+      ...super.toJSON(),
+      kind: LengthOfAssertionKind,
+    };
+    if (typeof this.value === 'number') {
+      result.value = this.value;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/LessThanAssertion.ts

@@ -0,0 +1,87 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const LessThanAssertionKind = 'HttpAction#LessThanAssertion';
+
+/**
+ * An assertion that makes sure the input value is less [or equal] to the set value.
+ */
+export interface ILessThanAssertion extends IHttpStep {
+  kind: typeof LessThanAssertionKind;
+
+  /**
+   * The value to compare to.
+   */
+  value?: number;
+
+  /**
+   * When set it treats the assertion as "greater than or equal"
+   */
+  equal?: boolean;
+}
+
+/**
+ * An assertion that makes sure the input value is less [or equal] to the set value.
+ */
+export class LessThanAssertion extends HttpStep {
+  override kind = LessThanAssertionKind;
+
+  /**
+   * The value to compare to.
+   */
+  value?: number;
+
+  /**
+   * When set it treats the assertion as "greater than or equal"
+   */
+  equal?: boolean;
+
+  constructor(value: number, equal?: boolean);
+
+  constructor(init: ILessThanAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: ILessThanAssertion | number, equal?: boolean) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as ILessThanAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'number') {
+      this.new({
+        kind: LessThanAssertionKind,
+        value: valueOrInit,
+        equal,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: ILessThanAssertion): void {
+    super.new(init);
+    this.kind = LessThanAssertionKind;
+    this.value = init.value;
+    if (typeof init.equal === 'boolean') {
+      this.equal = init.equal;
+    } else {
+      this.equal = undefined;
+    }
+  }
+
+  checkValidity(): boolean {
+    return typeof this.value === 'number';
+  }
+
+  override toJSON(): ILessThanAssertion {
+    const result: ILessThanAssertion = {
+      ...super.toJSON(),
+      kind: LessThanAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    if (typeof this.equal === 'boolean') {
+      result.equal = this.equal;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/MatchesAssertion.ts

@@ -0,0 +1,68 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const MatchesAssertionKind = 'HttpAction#MatchesAssertion';
+
+/**
+ * An assertion that makes sure the input value matches a regexp.
+ */
+export interface IMatchesAssertion extends IHttpStep {
+  kind: typeof MatchesAssertionKind;
+
+  /**
+   * The regexp to match the value against.
+   */
+  value?: string;
+}
+
+/**
+ * An assertion that makes sure the input value matches a regexp.
+ */
+export class MatchesAssertion extends HttpStep {
+  override kind = MatchesAssertionKind;
+
+  /**
+   * The regexp to match the value against.
+   */
+  value?: string;
+
+  constructor(value: string);
+
+  constructor(init: IMatchesAssertion);
+
+  constructor();
+
+  constructor(valueOrInit?: IMatchesAssertion | string) {
+    super();
+    if (typeof valueOrInit === 'object') {
+      const typed = valueOrInit as IMatchesAssertion;
+      this.new(typed);
+    } else if (typeof valueOrInit === 'string') {
+      this.new({
+        kind: MatchesAssertionKind,
+        value: valueOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IMatchesAssertion): void {
+    super.new(init);
+    this.kind = MatchesAssertionKind;
+    this.value = init.value;
+  }
+
+  checkValidity(): boolean {
+    return !!this.value;
+  }
+
+  override toJSON(): IMatchesAssertion {
+    const result: IMatchesAssertion = {
+      ...super.toJSON(),
+      kind: MatchesAssertionKind,
+    };
+    if (this.value) {
+      result.value = this.value;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/steps/assertion/MatchesSchemaAssertion.ts

@@ -0,0 +1,85 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const MatchesSchemaAssertionKind = 'HttpAction#MatchesSchemaAssertion';
+
+/**
+ * An assertion that makes sure the input matches a JSON schema. The input has to be a valid JSON string, object, or an array.
+ */
+export interface IMatchesSchemaAssertion extends IHttpStep {
+  kind: typeof MatchesSchemaAssertionKind;
+
+  /**
+   * The application internal reference to the schema stored in a store.
+   */
+  ref?: string;
+
+  /**
+   * When set it ignores the `ref` and uses this JSON schema to validate the input against.
+   */
+  schema?: unknown;
+}
+
+/**
+ * An assertion that makes sure the input matches a JSON schema. The input has to be a valid JSON string, object, or an array.
+ */
+export class MatchesSchemaAssertion extends HttpStep {
+  override kind = MatchesSchemaAssertionKind;
+
+  /**
+   * The application internal reference to the schema stored in a store.
+   */
+  ref?: string;
+
+  /**
+   * When set it ignores the `ref` and uses this JSON schema to validate the input against.
+   */
+  schema?: unknown;
+
+  static fromRef(ref: string): MatchesSchemaAssertion {
+    return new MatchesSchemaAssertion({
+      kind: MatchesSchemaAssertionKind,
+      enabled: true,
+      ref,
+    });
+  }
+
+  static fromSchema(schema: unknown): MatchesSchemaAssertion {
+    return new MatchesSchemaAssertion({
+      kind: MatchesSchemaAssertionKind,
+      enabled: true,
+      schema,
+    });
+  }
+
+  constructor(init?: IMatchesSchemaAssertion) {
+    super();
+    if (typeof init === 'object') {
+      this.new(init);
+    }
+  }
+
+  override new(init: IMatchesSchemaAssertion): void {
+    super.new(init);
+    this.kind = MatchesSchemaAssertionKind;
+    this.ref = init.ref;
+    this.schema = init.schema;
+  }
+
+  checkValidity(): boolean {
+    return !!this.schema || !!this.ref;
+  }
+
+  override toJSON(): IMatchesSchemaAssertion {
+    const result: IMatchesSchemaAssertion = {
+      ...super.toJSON(),
+      kind: MatchesSchemaAssertionKind,
+    };
+    if (this.ref) {
+      result.ref = this.ref;
+    }
+    if (this.schema) {
+      result.schema = this.schema;
+    }
+    return result;
+  }
+}