11447836208

Committed 21 Oct 2024 08:11PM UTC coverage: 41.761% (+0.02%) from 41.744%

Build # 11447836208

Build Type

Pull #380

github

Committed by

web-flow

Commit Message

Merge 1f05906ff into 02ff276c5

Pull Request Pull Request #380: chore: Update .codegen.json with commit hash of codegen and openapi spec

Run Details

4058 of 16792 branches covered (24.17%)

Branch coverage included in aggregate %.

4 of 10 new or added lines in 1 file covered. (40.0%)

5 existing lines in 1 file now uncovered.

13343 of 24876 relevant lines covered (53.64%)

78.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

20.75

/src/schemas/integrationMapping.generated.ts

import { serializeIntegrationMappingBaseTypeField } from './integrationMappingBase.generated.js';
import { deserializeIntegrationMappingBaseTypeField } from './integrationMappingBase.generated.js';
import { serializeIntegrationMappingBase } from './integrationMappingBase.generated.js';
import { deserializeIntegrationMappingBase } from './integrationMappingBase.generated.js';
import { serializeIntegrationMappingSlackOptions } from './integrationMappingSlackOptions.generated.js';
import { deserializeIntegrationMappingSlackOptions } from './integrationMappingSlackOptions.generated.js';
import { serializeUserIntegrationMappings } from './userIntegrationMappings.generated.js';
import { deserializeUserIntegrationMappings } from './userIntegrationMappings.generated.js';
import { serializeIntegrationMappingPartnerItemSlackUnion } from './integrationMappingPartnerItemSlackUnion.generated.js';
import { deserializeIntegrationMappingPartnerItemSlackUnion } from './integrationMappingPartnerItemSlackUnion.generated.js';
import { serializeFolderMini } from './folderMini.generated.js';
import { deserializeFolderMini } from './folderMini.generated.js';
import { serializeDateTime } from '../internal/utils.js';
import { deserializeDateTime } from '../internal/utils.js';
import { IntegrationMappingBaseTypeField } from './integrationMappingBase.generated.js';
import { IntegrationMappingBase } from './integrationMappingBase.generated.js';
import { IntegrationMappingSlackOptions } from './integrationMappingSlackOptions.generated.js';
import { UserIntegrationMappings } from './userIntegrationMappings.generated.js';
import { IntegrationMappingPartnerItemSlackUnion } from './integrationMappingPartnerItemSlackUnion.generated.js';
import { FolderMini } from './folderMini.generated.js';
import { DateTime } from '../internal/utils.js';
import { BoxSdkError } from '../box/errors.js';
import { SerializedData } from '../serialization/json.js';
import { sdIsEmpty } from '../serialization/json.js';
import { sdIsBoolean } from '../serialization/json.js';
import { sdIsNumber } from '../serialization/json.js';
import { sdIsString } from '../serialization/json.js';
import { sdIsList } from '../serialization/json.js';
import { sdIsMap } from '../serialization/json.js';
export type IntegrationMappingIntegrationTypeField = 'slack';
export class IntegrationMapping extends IntegrationMappingBase {
  readonly integrationType?: IntegrationMappingIntegrationTypeField;
  readonly isManuallyCreated?: boolean;
  readonly options?: IntegrationMappingSlackOptions;
  readonly createdBy?: UserIntegrationMappings;
  readonly modifiedBy?: UserIntegrationMappings;
  readonly partnerItem!: IntegrationMappingPartnerItemSlackUnion;
  readonly boxItem!: FolderMini;
  readonly createdAt?: DateTime;
  readonly modifiedAt?: DateTime;
  constructor(fields: IntegrationMapping) {
    super(fields);
  }
}
export function serializeIntegrationMappingIntegrationTypeField(
  val: IntegrationMappingIntegrationTypeField
): SerializedData {
  return val;
}
export function deserializeIntegrationMappingIntegrationTypeField(
  val: SerializedData
): IntegrationMappingIntegrationTypeField {
  if (val == 'slack') {
    return val;
  }
  throw new BoxSdkError({
    message: "Can't deserialize IntegrationMappingIntegrationTypeField",
  });
}
export function serializeIntegrationMapping(
  val: IntegrationMapping
): SerializedData {
  const base: any = serializeIntegrationMappingBase(val);
  if (!sdIsMap(base)) {
    throw new BoxSdkError({
      message: 'Expecting a map for "IntegrationMapping"',
    });
  }
  return {
    ...base,
    ...{
      ['integration_type']:
        val.integrationType == void 0
          ? void 0
          : serializeIntegrationMappingIntegrationTypeField(
              val.integrationType
            ),
      ['is_manually_created']:
        val.isManuallyCreated == void 0 ? void 0 : val.isManuallyCreated,
      ['options']:
        val.options == void 0
          ? void 0
          : serializeIntegrationMappingSlackOptions(val.options),
      ['created_by']:
        val.createdBy == void 0
          ? void 0
          : serializeUserIntegrationMappings(val.createdBy),
      ['modified_by']:
        val.modifiedBy == void 0
          ? void 0
          : serializeUserIntegrationMappings(val.modifiedBy),
      ['partner_item']: serializeIntegrationMappingPartnerItemSlackUnion(
        val.partnerItem
      ),
      ['box_item']: serializeFolderMini(val.boxItem),
      ['created_at']:
        val.createdAt == void 0 ? void 0 : serializeDateTime(val.createdAt),
      ['modified_at']:
        val.modifiedAt == void 0 ? void 0 : serializeDateTime(val.modifiedAt),
    },
  };
}
export function deserializeIntegrationMapping(
  val: SerializedData
): IntegrationMapping {
  if (!sdIsMap(val)) {
    throw new BoxSdkError({
      message: 'Expecting a map for "IntegrationMapping"',
    });
  }
  const integrationType: undefined | IntegrationMappingIntegrationTypeField =
    val.integration_type == void 0
      ? void 0
      : deserializeIntegrationMappingIntegrationTypeField(val.integration_type);
  if (
    !(val.is_manually_created == void 0) &&
    !sdIsBoolean(val.is_manually_created)
  ) {
    throw new BoxSdkError({
      message:
        'Expecting boolean for "is_manually_created" of type "IntegrationMapping"',
    });
  }
  const isManuallyCreated: undefined | boolean =
    val.is_manually_created == void 0 ? void 0 : val.is_manually_created;
  const options: undefined | IntegrationMappingSlackOptions =
    val.options == void 0
      ? void 0
      : deserializeIntegrationMappingSlackOptions(val.options);
  const createdBy: undefined | UserIntegrationMappings =
    val.created_by == void 0
      ? void 0
      : deserializeUserIntegrationMappings(val.created_by);
  const modifiedBy: undefined | UserIntegrationMappings =
    val.modified_by == void 0
      ? void 0
      : deserializeUserIntegrationMappings(val.modified_by);
  if (val.partner_item == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "partner_item" of type "IntegrationMapping" to be defined',
    });
  }
  const partnerItem: IntegrationMappingPartnerItemSlackUnion =
    deserializeIntegrationMappingPartnerItemSlackUnion(val.partner_item);
  if (val.box_item == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "box_item" of type "IntegrationMapping" to be defined',
    });
  }
  const boxItem: FolderMini = deserializeFolderMini(val.box_item);
  if (!(val.created_at == void 0) && !sdIsString(val.created_at)) {
    throw new BoxSdkError({
      message: 'Expecting string for "created_at" of type "IntegrationMapping"',
    });
  }
  const createdAt: undefined | DateTime =
    val.created_at == void 0 ? void 0 : deserializeDateTime(val.created_at);
  if (!(val.modified_at == void 0) && !sdIsString(val.modified_at)) {
    throw new BoxSdkError({
      message:
        'Expecting string for "modified_at" of type "IntegrationMapping"',
    });
  }
  const modifiedAt: undefined | DateTime =
    val.modified_at == void 0 ? void 0 : deserializeDateTime(val.modified_at);
  if (val.id == void 0) {
    throw new BoxSdkError({
      message: 'Expecting "id" of type "IntegrationMapping" to be defined',
    });
  }
  if (!sdIsString(val.id)) {
    throw new BoxSdkError({
      message: 'Expecting string for "id" of type "IntegrationMapping"',
    });
  }
  const id: string = val.id;
  if (val.type == void 0) {
    throw new BoxSdkError({
      message: 'Expecting "type" of type "IntegrationMapping" to be defined',
    });
  }
  const type: IntegrationMappingBaseTypeField =
    deserializeIntegrationMappingBaseTypeField(val.type);
  return {
    integrationType: integrationType,
    isManuallyCreated: isManuallyCreated,
    options: options,
    createdBy: createdBy,
    modifiedBy: modifiedBy,
    partnerItem: partnerItem,
    boxItem: boxItem,
    createdAt: createdAt,
    modifiedAt: modifiedAt,
    id: id,
    type: type,
  } satisfies IntegrationMapping;
}

1	import { serializeIntegrationMappingBaseTypeField } from './integrationMappingBase.generated.js';
2	import { deserializeIntegrationMappingBaseTypeField } from './integrationMappingBase.generated.js';	140✔
3	import { serializeIntegrationMappingBase } from './integrationMappingBase.generated.js';	140✔
4	import { deserializeIntegrationMappingBase } from './integrationMappingBase.generated.js';
5	import { serializeIntegrationMappingSlackOptions } from './integrationMappingSlackOptions.generated.js';	140✔
6	import { deserializeIntegrationMappingSlackOptions } from './integrationMappingSlackOptions.generated.js';	140✔
7	import { serializeUserIntegrationMappings } from './userIntegrationMappings.generated.js';	140✔
8	import { deserializeUserIntegrationMappings } from './userIntegrationMappings.generated.js';	140✔
9	import { serializeIntegrationMappingPartnerItemSlackUnion } from './integrationMappingPartnerItemSlackUnion.generated.js';	140✔
10	import { deserializeIntegrationMappingPartnerItemSlackUnion } from './integrationMappingPartnerItemSlackUnion.generated.js';	140✔
11	import { serializeFolderMini } from './folderMini.generated.js';	140✔
12	import { deserializeFolderMini } from './folderMini.generated.js';	140✔
13	import { serializeDateTime } from '../internal/utils.js';	140✔
14	import { deserializeDateTime } from '../internal/utils.js';	140✔
15	import { IntegrationMappingBaseTypeField } from './integrationMappingBase.generated.js';
16	import { IntegrationMappingBase } from './integrationMappingBase.generated.js';	140✔
17	import { IntegrationMappingSlackOptions } from './integrationMappingSlackOptions.generated.js';
18	import { UserIntegrationMappings } from './userIntegrationMappings.generated.js';
19	import { IntegrationMappingPartnerItemSlackUnion } from './integrationMappingPartnerItemSlackUnion.generated.js';
20	import { FolderMini } from './folderMini.generated.js';
21	import { DateTime } from '../internal/utils.js';
22	import { BoxSdkError } from '../box/errors.js';	140✔
23	import { SerializedData } from '../serialization/json.js';
24	import { sdIsEmpty } from '../serialization/json.js';
25	import { sdIsBoolean } from '../serialization/json.js';	140✔
26	import { sdIsNumber } from '../serialization/json.js';
27	import { sdIsString } from '../serialization/json.js';	140✔
28	import { sdIsList } from '../serialization/json.js';
29	import { sdIsMap } from '../serialization/json.js';	140✔
30	export type IntegrationMappingIntegrationTypeField = 'slack';
31	export class IntegrationMapping extends IntegrationMappingBase {	140✔
32	readonly integrationType?: IntegrationMappingIntegrationTypeField;
33	readonly isManuallyCreated?: boolean;
34	readonly options?: IntegrationMappingSlackOptions;
35	readonly createdBy?: UserIntegrationMappings;
36	readonly modifiedBy?: UserIntegrationMappings;
37	readonly partnerItem!: IntegrationMappingPartnerItemSlackUnion;
38	readonly boxItem!: FolderMini;
39	readonly createdAt?: DateTime;
40	readonly modifiedAt?: DateTime;
41	constructor(fields: IntegrationMapping) {
42	super(fields);	×
43	}
44	}
45	export function serializeIntegrationMappingIntegrationTypeField(	140✔
46	val: IntegrationMappingIntegrationTypeField
47	): SerializedData {
48	return val;	×
49	}
50	export function deserializeIntegrationMappingIntegrationTypeField(	140✔
51	val: SerializedData
52	): IntegrationMappingIntegrationTypeField {
53	if (val == 'slack') {	×
54	return val;	×
55	}
56	throw new BoxSdkError({	×
57	message: "Can't deserialize IntegrationMappingIntegrationTypeField",
58	});
59	}
60	export function serializeIntegrationMapping(	140✔
61	val: IntegrationMapping
62	): SerializedData {
63	const base: any = serializeIntegrationMappingBase(val);	×
64	if (!sdIsMap(base)) {	×
65	throw new BoxSdkError({	×
66	message: 'Expecting a map for "IntegrationMapping"',
67	});
68	}
69	return {	×
70	...base,
71	...{
72	['integration_type']:
73	val.integrationType == void 0	×
74	? void 0
75	: serializeIntegrationMappingIntegrationTypeField(
76	val.integrationType
77	),
78	['is_manually_created']:
79	val.isManuallyCreated == void 0 ? void 0 : val.isManuallyCreated,	×
80	['options']:
81	val.options == void 0	×
82	? void 0
83	: serializeIntegrationMappingSlackOptions(val.options),
84	['created_by']:
85	val.createdBy == void 0	×
86	? void 0
87	: serializeUserIntegrationMappings(val.createdBy),
88	['modified_by']:
89	val.modifiedBy == void 0	×
90	? void 0
91	: serializeUserIntegrationMappings(val.modifiedBy),
92	['partner_item']: serializeIntegrationMappingPartnerItemSlackUnion(
93	val.partnerItem
94	),
95	['box_item']: serializeFolderMini(val.boxItem),
96	['created_at']:
97	val.createdAt == void 0 ? void 0 : serializeDateTime(val.createdAt),	×
98	['modified_at']:
99	val.modifiedAt == void 0 ? void 0 : serializeDateTime(val.modifiedAt),	×
100	},
101	};
102	}
103	export function deserializeIntegrationMapping(	140✔
104	val: SerializedData
105	): IntegrationMapping {
106	if (!sdIsMap(val)) {	×
107	throw new BoxSdkError({	×
108	message: 'Expecting a map for "IntegrationMapping"',
109	});
110	}
111	const integrationType: undefined \| IntegrationMappingIntegrationTypeField =
112	val.integration_type == void 0	×
113	? void 0
114	: deserializeIntegrationMappingIntegrationTypeField(val.integration_type);
115	if (	×
116	!(val.is_manually_created == void 0) &&	×
117	!sdIsBoolean(val.is_manually_created)
118	) {
119	throw new BoxSdkError({	×
120	message:
121	'Expecting boolean for "is_manually_created" of type "IntegrationMapping"',
122	});
123	}
124	const isManuallyCreated: undefined \| boolean =
125	val.is_manually_created == void 0 ? void 0 : val.is_manually_created;	×
126	const options: undefined \| IntegrationMappingSlackOptions =
127	val.options == void 0	×
128	? void 0
129	: deserializeIntegrationMappingSlackOptions(val.options);
130	const createdBy: undefined \| UserIntegrationMappings =
131	val.created_by == void 0	×
132	? void 0
133	: deserializeUserIntegrationMappings(val.created_by);
134	const modifiedBy: undefined \| UserIntegrationMappings =
135	val.modified_by == void 0	×
136	? void 0
137	: deserializeUserIntegrationMappings(val.modified_by);
NEW 138	if (val.partner_item == void 0) {	×
NEW 139	throw new BoxSdkError({	×
140	message:
141	'Expecting "partner_item" of type "IntegrationMapping" to be defined',
142	});
143	}
144	const partnerItem: IntegrationMappingPartnerItemSlackUnion =
NEW 145	deserializeIntegrationMappingPartnerItemSlackUnion(val.partner_item);	×
NEW 146	if (val.box_item == void 0) {	×
NEW 147	throw new BoxSdkError({	×
148	message:
149	'Expecting "box_item" of type "IntegrationMapping" to be defined',
150	});
151	}
NEW 152	const boxItem: FolderMini = deserializeFolderMini(val.box_item);	×
153	if (!(val.created_at == void 0) && !sdIsString(val.created_at)) {	×
154	throw new BoxSdkError({	×
155	message: 'Expecting string for "created_at" of type "IntegrationMapping"',
156	});
157	}
158	const createdAt: undefined \| DateTime =
159	val.created_at == void 0 ? void 0 : deserializeDateTime(val.created_at);	×
160	if (!(val.modified_at == void 0) && !sdIsString(val.modified_at)) {	×
161	throw new BoxSdkError({	×
162	message:
163	'Expecting string for "modified_at" of type "IntegrationMapping"',
164	});
165	}
166	const modifiedAt: undefined \| DateTime =
167	val.modified_at == void 0 ? void 0 : deserializeDateTime(val.modified_at);	×
168	if (val.id == void 0) {	×
169	throw new BoxSdkError({	×
170	message: 'Expecting "id" of type "IntegrationMapping" to be defined',
171	});
172	}
173	if (!sdIsString(val.id)) {	×
174	throw new BoxSdkError({	×
175	message: 'Expecting string for "id" of type "IntegrationMapping"',
176	});
177	}
178	const id: string = val.id;	×
179	if (val.type == void 0) {	×
180	throw new BoxSdkError({	×
181	message: 'Expecting "type" of type "IntegrationMapping" to be defined',
182	});
183	}
184	const type: IntegrationMappingBaseTypeField =
185	deserializeIntegrationMappingBaseTypeField(val.type);	×
186	return {	×
187	integrationType: integrationType,
188	isManuallyCreated: isManuallyCreated,
189	options: options,
190	createdBy: createdBy,
191	modifiedBy: modifiedBy,
192	partnerItem: partnerItem,
193	boxItem: boxItem,
194	createdAt: createdAt,
195	modifiedAt: modifiedAt,
196	id: id,
197	type: type,
198	} satisfies IntegrationMapping;
199	}

box / box-typescript-sdk-gen / 11447836208

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous