box-node-sdk 10.1.0 → 10.3.0

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;
+}

package/src/schemas/signRequestSignerInputNumberWithPeriodValidation.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 SignRequestSignerInputNumberWithPeriodValidationValidationTypeField =
+  'number_with_period' | string;
+export interface SignRequestSignerInputNumberWithPeriodValidation {
+  /**
+   * Validates that the text input uses a number format with a period as the decimal separator (for example, 1.23). */
+  readonly validationType?: SignRequestSignerInputNumberWithPeriodValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputNumberWithPeriodValidationValidationTypeField(
+  val: SignRequestSignerInputNumberWithPeriodValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputNumberWithPeriodValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputNumberWithPeriodValidationValidationTypeField {
+  if (val == 'number_with_period') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputNumberWithPeriodValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputNumberWithPeriodValidation(
+  val: SignRequestSignerInputNumberWithPeriodValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputNumberWithPeriodValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputNumberWithPeriodValidation(
+  val: SerializedData,
+): SignRequestSignerInputNumberWithPeriodValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message:
+        'Expecting a map for "SignRequestSignerInputNumberWithPeriodValidation"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputNumberWithPeriodValidationValidationTypeField =
+    val.validation_type == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputNumberWithPeriodValidationValidationTypeField(
+          val.validation_type,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputNumberWithPeriodValidation;
+}

package/src/schemas/signRequestSignerInputSsnValidation.ts

@@ -0,0 +1,118 @@
+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 SignRequestSignerInputSsnValidationValidationTypeField =
+  | 'ssn'
+  | string;
+export class SignRequestSignerInputSsnValidation {
+  /**
+   * Validates that the text input is a Social Security Number (SSN). */
+  readonly validationType: SignRequestSignerInputSsnValidationValidationTypeField =
+    'ssn' as SignRequestSignerInputSsnValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+  constructor(
+    fields: Omit<SignRequestSignerInputSsnValidation, 'validationType'> &
+      Partial<Pick<SignRequestSignerInputSsnValidation, 'validationType'>>,
+  ) {
+    if (fields.validationType !== undefined) {
+      this.validationType = fields.validationType;
+    }
+    if (fields.rawData !== undefined) {
+      this.rawData = fields.rawData;
+    }
+  }
+}
+export interface SignRequestSignerInputSsnValidationInput {
+  /**
+   * Validates that the text input is a Social Security Number (SSN). */
+  readonly validationType?: SignRequestSignerInputSsnValidationValidationTypeField;
+  readonly rawData?: SerializedData;
+}
+export function serializeSignRequestSignerInputSsnValidationValidationTypeField(
+  val: SignRequestSignerInputSsnValidationValidationTypeField,
+): SerializedData {
+  return val;
+}
+export function deserializeSignRequestSignerInputSsnValidationValidationTypeField(
+  val: SerializedData,
+): SignRequestSignerInputSsnValidationValidationTypeField {
+  if (val == 'ssn') {
+    return val;
+  }
+  if (sdIsString(val)) {
+    return val;
+  }
+  throw new BoxSdkError({
+    message:
+      "Can't deserialize SignRequestSignerInputSsnValidationValidationTypeField",
+  });
+}
+export function serializeSignRequestSignerInputSsnValidation(
+  val: SignRequestSignerInputSsnValidation,
+): SerializedData {
+  return {
+    ['validation_type']:
+      serializeSignRequestSignerInputSsnValidationValidationTypeField(
+        val.validationType,
+      ),
+  };
+}
+export function deserializeSignRequestSignerInputSsnValidation(
+  val: SerializedData,
+): SignRequestSignerInputSsnValidation {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputSsnValidation"',
+    });
+  }
+  if (val.validation_type == void 0) {
+    throw new BoxSdkError({
+      message:
+        'Expecting "validation_type" of type "SignRequestSignerInputSsnValidation" to be defined',
+    });
+  }
+  const validationType: SignRequestSignerInputSsnValidationValidationTypeField =
+    deserializeSignRequestSignerInputSsnValidationValidationTypeField(
+      val.validation_type,
+    );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputSsnValidation;
+}
+export function serializeSignRequestSignerInputSsnValidationInput(
+  val: SignRequestSignerInputSsnValidationInput,
+): SerializedData {
+  return {
+    ['validationType']:
+      val.validationType == void 0
+        ? val.validationType
+        : serializeSignRequestSignerInputSsnValidationValidationTypeField(
+            val.validationType,
+          ),
+  };
+}
+export function deserializeSignRequestSignerInputSsnValidationInput(
+  val: SerializedData,
+): SignRequestSignerInputSsnValidationInput {
+  if (!sdIsMap(val)) {
+    throw new BoxSdkError({
+      message: 'Expecting a map for "SignRequestSignerInputSsnValidationInput"',
+    });
+  }
+  const validationType:
+    | undefined
+    | SignRequestSignerInputSsnValidationValidationTypeField =
+    val.validationType == void 0
+      ? void 0
+      : deserializeSignRequestSignerInputSsnValidationValidationTypeField(
+          val.validationType,
+        );
+  return {
+    validationType: validationType,
+  } satisfies SignRequestSignerInputSsnValidationInput;
+}