box-node-sdk 10.2.0 → 10.3.0

package/src/schemas/signRequestSignerInputCustomValidation.ts

@@ -0,0 +1,185 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export type SignRequestSignerInputCustomValidationValidationTypeField =
+  | 'custom'
+  | string;
+export class SignRequestSignerInputCustomValidation {
+  /**
+   * Defines the validation format for the text input as custom.
+   * A custom regular expression is used for validation. */
+  readonly validationType: SignRequestSignerInputCustomValidationValidationTypeField =
+    'custom' as SignRequestSignerInputCustomValidationValidationTypeField;
+  /**
+   * Regular expression used for validation. */
+  readonly customRegex?: string | null;
+  /**
+   * Error message shown if input fails custom regular expression validation. */
+  readonly customErrorMessage?: string | null;
+  readonly rawData?: SerializedData;
+  constructor(
+    fields: Omit<SignRequestSignerInputCustomValidation, 'validationType'> &
+      Partial<Pick<SignRequestSignerInputCustomValidation, 'validationType'>>,
+  ) {
+    if (fields.validationType !== undefined) {
+      this.validationType = fields.validationType;
+    }
+    if (fields.customRegex !== undefined) {
+      this.customRegex = fields.customRegex;
+    }
+    if (fields.customErrorMessage !== undefined) {
+      this.customErrorMessage = fields.customErrorMessage;
+    }
+    if (fields.rawData !== undefined) {
+      this.rawData = fields.rawData;
+    }
+  }
+}
+export interface SignRequestSignerInputCustomValidationInput {
+  /**
+   * Defines the validation format for the text input as custom.
+   * A custom regular expression is used for validation. */
+  readonly validationType?: SignRequestSignerInputCustomValidationValidationTypeField;
+  /**
+   * Regular expression used for validation. */
+  readonly customRegex?: string | null;
+  /**
+   * Error message shown if input fails custom regular expression validation. */
+  readonly customErrorMessage?: string | null;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputCustomValidationValidationTypeField(
+  val: SignRequestSignerInputCustomValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputCustomValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputCustomValidationValidationTypeField {
+  if (val == 'custom') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputCustomValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputCustomValidation(
+  val: SignRequestSignerInputCustomValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      serializeSignRequestSignerInputCustomValidationValidationTypeField(
+        val.validationType,
+      ),
+    ['custom_regex']: val.customRegex,
+    ['custom_error_message']: val.customErrorMessage,
+  };
+}
+export function deserializeSignRequestSignerInputCustomValidation(
+  val: SerializedData,
+): SignRequestSignerInputCustomValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputCustomValidation"',
+    });
+  }
+  if (val.validation_type == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "validation_type" of type "SignRequestSignerInputCustomValidation" to be defined',
+    });
+  }
+  const validationType: SignRequestSignerInputCustomValidationValidationTypeField =
+    deserializeSignRequestSignerInputCustomValidationValidationTypeField(
+      val.validation_type,
+    );
+  if (!(val.custom_regex == void 0) && !sdIsString(val.custom_regex)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "custom_regex" of type "SignRequestSignerInputCustomValidation"',
+    });
+  }
+  const customRegex: undefined | string =
+    val.custom_regex == void 0 ? void 0 : val.custom_regex;
+  if (
+    !(val.custom_error_message == void 0) &&
+    !sdIsString(val.custom_error_message)
+  ) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "custom_error_message" of type "SignRequestSignerInputCustomValidation"',
+    });
+  }
+  const customErrorMessage: undefined | string =
+    val.custom_error_message == void 0 ? void 0 : val.custom_error_message;
+  return {
+    validationType: validationType,
+    customRegex: customRegex,
+    customErrorMessage: customErrorMessage,
+  } satisfies SignRequestSignerInputCustomValidation;
+}
+export function serializeSignRequestSignerInputCustomValidationInput(
+  val: SignRequestSignerInputCustomValidationInput,
+): SerializedData {
+  return {
+    ['validationType']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputCustomValidationValidationTypeField(
+            val.validationType,
+          ),
+    ['custom_regex']: val.customRegex,
+    ['custom_error_message']: val.customErrorMessage,
+  };
+}
+export function deserializeSignRequestSignerInputCustomValidationInput(
+  val: SerializedData,
+): SignRequestSignerInputCustomValidationInput {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting a map for "SignRequestSignerInputCustomValidationInput"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputCustomValidationValidationTypeField =
+    val.validationType == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputCustomValidationValidationTypeField(
+          val.validationType,
+        );
+  if (!(val.custom_regex == void 0) && !sdIsString(val.custom_regex)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "custom_regex" of type "SignRequestSignerInputCustomValidationInput"',
+    });
+  }
+  const customRegex: undefined | string =
+    val.custom_regex == void 0 ? void 0 : val.custom_regex;
+  if (
+    !(val.custom_error_message == void 0) &&
+    !sdIsString(val.custom_error_message)
+  ) {
+    throw new BoxSdkError({
+      message:
+        'Expecting string for "custom_error_message" of type "SignRequestSignerInputCustomValidationInput"',
+    });
+  }
+  const customErrorMessage: undefined | string =
+    val.custom_error_message == void 0 ? void 0 : val.custom_error_message;
+  return {
+    validationType: validationType,
+    customRegex: customRegex,
+    customErrorMessage: customErrorMessage,
+  } satisfies SignRequestSignerInputCustomValidationInput;
+}

package/src/schemas/signRequestSignerInputDateAsiaValidation.ts

@@ -0,0 +1,68 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export type SignRequestSignerInputDateAsiaValidationValidationTypeField =
+  | 'date_asia'
+  | string;
+export interface SignRequestSignerInputDateAsiaValidation {
+  /**
+   * Validates that the text input uses the Asian date format `YYYY/MM/DD`. */
+  readonly validationType?: SignRequestSignerInputDateAsiaValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputDateAsiaValidationValidationTypeField(
+  val: SignRequestSignerInputDateAsiaValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputDateAsiaValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputDateAsiaValidationValidationTypeField {
+  if (val == 'date_asia') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputDateAsiaValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputDateAsiaValidation(
+  val: SignRequestSignerInputDateAsiaValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputDateAsiaValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputDateAsiaValidation(
+  val: SerializedData,
+): SignRequestSignerInputDateAsiaValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputDateAsiaValidation"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputDateAsiaValidationValidationTypeField =
+    val.validation_type == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputDateAsiaValidationValidationTypeField(
+          val.validation_type,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputDateAsiaValidation;
+}

package/src/schemas/signRequestSignerInputDateEuValidation.ts

@@ -0,0 +1,68 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export type SignRequestSignerInputDateEuValidationValidationTypeField =
+  | 'date_eu'
+  | string;
+export interface SignRequestSignerInputDateEuValidation {
+  /**
+   * Validates that the text input uses the European date format `DD/MM/YYYY`. */
+  readonly validationType?: SignRequestSignerInputDateEuValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputDateEuValidationValidationTypeField(
+  val: SignRequestSignerInputDateEuValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputDateEuValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputDateEuValidationValidationTypeField {
+  if (val == 'date_eu') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputDateEuValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputDateEuValidation(
+  val: SignRequestSignerInputDateEuValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputDateEuValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputDateEuValidation(
+  val: SerializedData,
+): SignRequestSignerInputDateEuValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputDateEuValidation"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputDateEuValidationValidationTypeField =
+    val.validation_type == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputDateEuValidationValidationTypeField(
+          val.validation_type,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputDateEuValidation;
+}

package/src/schemas/signRequestSignerInputDateIsoValidation.ts

@@ -0,0 +1,68 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export type SignRequestSignerInputDateIsoValidationValidationTypeField =
+  | 'date_iso'
+  | string;
+export interface SignRequestSignerInputDateIsoValidation {
+  /**
+   * Validates that the text input uses the ISO date format `YYYY-MM-DD`. */
+  readonly validationType?: SignRequestSignerInputDateIsoValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputDateIsoValidationValidationTypeField(
+  val: SignRequestSignerInputDateIsoValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputDateIsoValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputDateIsoValidationValidationTypeField {
+  if (val == 'date_iso') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputDateIsoValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputDateIsoValidation(
+  val: SignRequestSignerInputDateIsoValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputDateIsoValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputDateIsoValidation(
+  val: SerializedData,
+): SignRequestSignerInputDateIsoValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputDateIsoValidation"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputDateIsoValidationValidationTypeField =
+    val.validation_type == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputDateIsoValidationValidationTypeField(
+          val.validation_type,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputDateIsoValidation;
+}

package/src/schemas/signRequestSignerInputDateUsValidation.ts

@@ -0,0 +1,68 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export type SignRequestSignerInputDateUsValidationValidationTypeField =
+  | 'date_us'
+  | string;
+export interface SignRequestSignerInputDateUsValidation {
+  /**
+   * Validates that the text input uses the US date format `MM/DD/YYYY`. */
+  readonly validationType?: SignRequestSignerInputDateUsValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputDateUsValidationValidationTypeField(
+  val: SignRequestSignerInputDateUsValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputDateUsValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputDateUsValidationValidationTypeField {
+  if (val == 'date_us') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputDateUsValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputDateUsValidation(
+  val: SignRequestSignerInputDateUsValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputDateUsValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputDateUsValidation(
+  val: SerializedData,
+): SignRequestSignerInputDateUsValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputDateUsValidation"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputDateUsValidationValidationTypeField =
+    val.validation_type == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputDateUsValidationValidationTypeField(
+          val.validation_type,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputDateUsValidation;
+}

package/src/schemas/signRequestSignerInputEmailValidation.ts

@@ -0,0 +1,119 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export type SignRequestSignerInputEmailValidationValidationTypeField =
+  | 'email'
+  | string;
+export class SignRequestSignerInputEmailValidation {
+  /**
+   * Validates that the text input is an email address. */
+  readonly validationType: SignRequestSignerInputEmailValidationValidationTypeField =
+    'email' as SignRequestSignerInputEmailValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+  constructor(
+    fields: Omit<SignRequestSignerInputEmailValidation, 'validationType'> &
+      Partial<Pick<SignRequestSignerInputEmailValidation, 'validationType'>>,
+  ) {
+    if (fields.validationType !== undefined) {
+      this.validationType = fields.validationType;
+    }
+    if (fields.rawData !== undefined) {
+      this.rawData = fields.rawData;
+    }
+  }
+}
+export interface SignRequestSignerInputEmailValidationInput {
+  /**
+   * Validates that the text input is an email address. */
+  readonly validationType?: SignRequestSignerInputEmailValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputEmailValidationValidationTypeField(
+  val: SignRequestSignerInputEmailValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputEmailValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputEmailValidationValidationTypeField {
+  if (val == 'email') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputEmailValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputEmailValidation(
+  val: SignRequestSignerInputEmailValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      serializeSignRequestSignerInputEmailValidationValidationTypeField(
+        val.validationType,
+      ),
+  };
+}
+export function deserializeSignRequestSignerInputEmailValidation(
+  val: SerializedData,
+): SignRequestSignerInputEmailValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputEmailValidation"',
+    });
+  }
+  if (val.validation_type == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "validation_type" of type "SignRequestSignerInputEmailValidation" to be defined',
+    });
+  }
+  const validationType: SignRequestSignerInputEmailValidationValidationTypeField =
+    deserializeSignRequestSignerInputEmailValidationValidationTypeField(
+      val.validation_type,
+    );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputEmailValidation;
+}
+export function serializeSignRequestSignerInputEmailValidationInput(
+  val: SignRequestSignerInputEmailValidationInput,
+): SerializedData {
+  return {
+    ['validationType']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputEmailValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputEmailValidationInput(
+  val: SerializedData,
+): SignRequestSignerInputEmailValidationInput {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting a map for "SignRequestSignerInputEmailValidationInput"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputEmailValidationValidationTypeField =
+    val.validationType == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputEmailValidationValidationTypeField(
+          val.validationType,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputEmailValidationInput;
+}

package/src/schemas/signRequestSignerInputNumberWithCommaValidation.ts

@@ -0,0 +1,69 @@
+import { BoxSdkError } from '../box/errors';
+import { SerializedData } from '../serialization/json';
+import { sdIsEmpty } from '../serialization/json';
+import { sdIsBoolean } from '../serialization/json';
+import { sdIsNumber } from '../serialization/json';
+import { sdIsString } from '../serialization/json';
+import { sdIsList } from '../serialization/json';
+import { sdIsMap } from '../serialization/json';
+export type SignRequestSignerInputNumberWithCommaValidationValidationTypeField =
+  | 'number_with_comma'
+  | string;
+export interface SignRequestSignerInputNumberWithCommaValidation {
+  /**
+   * Validates that the text input uses a number format with a comma as the decimal separator (for example, 1,23). */
+  readonly validationType?: SignRequestSignerInputNumberWithCommaValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputNumberWithCommaValidationValidationTypeField(
+  val: SignRequestSignerInputNumberWithCommaValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputNumberWithCommaValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputNumberWithCommaValidationValidationTypeField {
+  if (val == 'number_with_comma') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputNumberWithCommaValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputNumberWithCommaValidation(
+  val: SignRequestSignerInputNumberWithCommaValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputNumberWithCommaValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputNumberWithCommaValidation(
+  val: SerializedData,
+): SignRequestSignerInputNumberWithCommaValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting a map for "SignRequestSignerInputNumberWithCommaValidation"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputNumberWithCommaValidationValidationTypeField =
+    val.validation_type == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputNumberWithCommaValidationValidationTypeField(
+          val.validation_type,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputNumberWithCommaValidation;
+}