12870156465

Committed 20 Jan 2025 02:28PM UTC coverage: 42.419%. First build

Build # 12870156465

Build Type

push

github

Committed by

web-flow

Commit Message

feat: Use extensible enums (box/box-codegen#639) (#487)

Coverage Stats

3990 of 15999 branches covered (24.94%)

Branch coverage included in aggregate %.

0 of 408 new or added lines in 104 files covered. (0.0%)

14249 of 26998 relevant lines covered (52.78%)

93.02 hits per line

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

60.45

/src/managers/folderWatermarks.generated.ts

import { serializeWatermark } from '../schemas/watermark.generated.js';
import { deserializeWatermark } from '../schemas/watermark.generated.js';
import { serializeClientError } from '../schemas/clientError.generated.js';
import { deserializeClientError } from '../schemas/clientError.generated.js';
import { ResponseFormat } from '../networking/fetchOptions.generated.js';
import { Watermark } from '../schemas/watermark.generated.js';
import { ClientError } from '../schemas/clientError.generated.js';
import { BoxSdkError } from '../box/errors.js';
import { Authentication } from '../networking/auth.generated.js';
import { NetworkSession } from '../networking/network.generated.js';
import { FetchOptions } from '../networking/fetchOptions.generated.js';
import { FetchResponse } from '../networking/fetchResponse.generated.js';
import { prepareParams } from '../internal/utils.js';
import { toString } from '../internal/utils.js';
import { ByteStream } from '../internal/utils.js';
import { CancellationToken } from '../internal/utils.js';
import { sdToJson } from '../serialization/json.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 class GetFolderWatermarkOptionals {
  readonly headers: GetFolderWatermarkHeaders = new GetFolderWatermarkHeaders(
    {},
  );
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<GetFolderWatermarkOptionals, 'headers' | 'cancellationToken'> &
      Partial<
        Pick<GetFolderWatermarkOptionals, 'headers' | 'cancellationToken'>
      >,
  ) {
    if (fields.headers !== undefined) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken !== undefined) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface GetFolderWatermarkOptionalsInput {
  readonly headers?: GetFolderWatermarkHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class UpdateFolderWatermarkOptionals {
  readonly headers: UpdateFolderWatermarkHeaders =
    new UpdateFolderWatermarkHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<
      UpdateFolderWatermarkOptionals,
      'headers' | 'cancellationToken'
    > &
      Partial<
        Pick<UpdateFolderWatermarkOptionals, 'headers' | 'cancellationToken'>
      >,
  ) {
    if (fields.headers !== undefined) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken !== undefined) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface UpdateFolderWatermarkOptionalsInput {
  readonly headers?: UpdateFolderWatermarkHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class DeleteFolderWatermarkOptionals {
  readonly headers: DeleteFolderWatermarkHeaders =
    new DeleteFolderWatermarkHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<
      DeleteFolderWatermarkOptionals,
      'headers' | 'cancellationToken'
    > &
      Partial<
        Pick<DeleteFolderWatermarkOptionals, 'headers' | 'cancellationToken'>
      >,
  ) {
    if (fields.headers !== undefined) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken !== undefined) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface DeleteFolderWatermarkOptionalsInput {
  readonly headers?: DeleteFolderWatermarkHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class GetFolderWatermarkHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<GetFolderWatermarkHeaders, 'extraHeaders'> &
      Partial<Pick<GetFolderWatermarkHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface GetFolderWatermarkHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export type UpdateFolderWatermarkRequestBodyWatermarkImprintField =
  | 'default'
  | string;
export class UpdateFolderWatermarkRequestBodyWatermarkField {
  /**
   * The type of watermark to apply.
   *
   * Currently only supports one option. */
  readonly imprint: UpdateFolderWatermarkRequestBodyWatermarkImprintField =
    'default' as UpdateFolderWatermarkRequestBodyWatermarkImprintField;
  readonly rawData?: SerializedData;
  constructor(
    fields: Omit<UpdateFolderWatermarkRequestBodyWatermarkField, 'imprint'> &
      Partial<Pick<UpdateFolderWatermarkRequestBodyWatermarkField, 'imprint'>>,
  ) {
    if (fields.imprint !== undefined) {
      this.imprint = fields.imprint;
    }
    if (fields.rawData !== undefined) {
      this.rawData = fields.rawData;
    }
  }
}
export interface UpdateFolderWatermarkRequestBodyWatermarkFieldInput {
  /**
   * The type of watermark to apply.
   *
   * Currently only supports one option. */
  readonly imprint?: UpdateFolderWatermarkRequestBodyWatermarkImprintField;
  readonly rawData?: SerializedData;
}
export interface UpdateFolderWatermarkRequestBody {
  /**
   * The watermark to imprint on the folder */
  readonly watermark: UpdateFolderWatermarkRequestBodyWatermarkField;
  readonly rawData?: SerializedData;
}
export class UpdateFolderWatermarkHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<UpdateFolderWatermarkHeaders, 'extraHeaders'> &
      Partial<Pick<UpdateFolderWatermarkHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface UpdateFolderWatermarkHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class DeleteFolderWatermarkHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<DeleteFolderWatermarkHeaders, 'extraHeaders'> &
      Partial<Pick<DeleteFolderWatermarkHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface DeleteFolderWatermarkHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class FolderWatermarksManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields: Omit<
      FolderWatermarksManager,
      | 'networkSession'
      | 'getFolderWatermark'
      | 'updateFolderWatermark'
      | 'deleteFolderWatermark'
    > &
      Partial<Pick<FolderWatermarksManager, 'networkSession'>>,
  ) {
    if (fields.auth !== undefined) {
      this.auth = fields.auth;
    }
    if (fields.networkSession !== undefined) {
      this.networkSession = fields.networkSession;
    }
  }
  /**
     * Retrieve the watermark for a folder.
     * @param {string} folderId The unique identifier that represent a folder.
    
    The ID for any folder can be determined
    by visiting this folder in the web application
    and copying the ID from the URL. For example,
    for the URL `https://*.app.box.com/folder/123`
    the `folder_id` is `123`.
    
    The root folder of a Box account is
    always represented by the ID `0`.
    Example: "12345"
     * @param {GetFolderWatermarkOptionalsInput} optionalsInput
     * @returns {Promise<Watermark>}
     */
  async getFolderWatermark(
    folderId: string,
    optionalsInput: GetFolderWatermarkOptionalsInput = {},
  ): Promise<Watermark> {
    const optionals: GetFolderWatermarkOptionals =
      new GetFolderWatermarkOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folders/',
            toString(folderId) as string,
            '/watermark',
          ) as string,
          method: 'GET',
          headers: headersMap,
          responseFormat: 'json' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return {
      ...deserializeWatermark(response.data!),
      rawData: response.data!,
    };
  }
  /**
     * Applies or update a watermark on a folder.
     * @param {string} folderId The unique identifier that represent a folder.
    
    The ID for any folder can be determined
    by visiting this folder in the web application
    and copying the ID from the URL. For example,
    for the URL `https://*.app.box.com/folder/123`
    the `folder_id` is `123`.
    
    The root folder of a Box account is
    always represented by the ID `0`.
    Example: "12345"
     * @param {UpdateFolderWatermarkRequestBody} requestBody Request body of updateFolderWatermark method
     * @param {UpdateFolderWatermarkOptionalsInput} optionalsInput
     * @returns {Promise<Watermark>}
     */
  async updateFolderWatermark(
    folderId: string,
    requestBody: UpdateFolderWatermarkRequestBody,
    optionalsInput: UpdateFolderWatermarkOptionalsInput = {},
  ): Promise<Watermark> {
    const optionals: UpdateFolderWatermarkOptionals =
      new UpdateFolderWatermarkOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folders/',
            toString(folderId) as string,
            '/watermark',
          ) as string,
          method: 'PUT',
          headers: headersMap,
          data: serializeUpdateFolderWatermarkRequestBody(requestBody),
          contentType: 'application/json',
          responseFormat: 'json' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return {
      ...deserializeWatermark(response.data!),
      rawData: response.data!,
    };
  }
  /**
     * Removes the watermark from a folder.
     * @param {string} folderId The unique identifier that represent a folder.
    
    The ID for any folder can be determined
    by visiting this folder in the web application
    and copying the ID from the URL. For example,
    for the URL `https://*.app.box.com/folder/123`
    the `folder_id` is `123`.
    
    The root folder of a Box account is
    always represented by the ID `0`.
    Example: "12345"
     * @param {DeleteFolderWatermarkOptionalsInput} optionalsInput
     * @returns {Promise<undefined>}
     */
  async deleteFolderWatermark(
    folderId: string,
    optionalsInput: DeleteFolderWatermarkOptionalsInput = {},
  ): Promise<undefined> {
    const optionals: DeleteFolderWatermarkOptionals =
      new DeleteFolderWatermarkOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folders/',
            toString(folderId) as string,
            '/watermark',
          ) as string,
          method: 'DELETE',
          headers: headersMap,
          responseFormat: 'no_content' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return void 0;
  }
}
export interface FolderWatermarksManagerInput {
  readonly auth?: Authentication;
  readonly networkSession?: NetworkSession;
}
export function serializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
  val: UpdateFolderWatermarkRequestBodyWatermarkImprintField,
): SerializedData {
  return val;
}
export function deserializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
  val: SerializedData,
): UpdateFolderWatermarkRequestBodyWatermarkImprintField {
  if (val == 'default') {
    return val;
  }
  if (sdIsString(val)) {
    return val;
  }
  throw new BoxSdkError({
    message:
      "Can't deserialize UpdateFolderWatermarkRequestBodyWatermarkImprintField",
  });
}
export function serializeUpdateFolderWatermarkRequestBodyWatermarkField(
  val: UpdateFolderWatermarkRequestBodyWatermarkField,
): SerializedData {
  return {
    ['imprint']: serializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
      val.imprint,
    ),
  };
}
export function deserializeUpdateFolderWatermarkRequestBodyWatermarkField(
  val: SerializedData,
): UpdateFolderWatermarkRequestBodyWatermarkField {
  if (!sdIsMap(val)) {
    throw new BoxSdkError({
      message:
        'Expecting a map for "UpdateFolderWatermarkRequestBodyWatermarkField"',
    });
  }
  if (val.imprint == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "imprint" of type "UpdateFolderWatermarkRequestBodyWatermarkField" to be defined',
    });
  }
  const imprint: UpdateFolderWatermarkRequestBodyWatermarkImprintField =
    deserializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
      val.imprint,
    );
  return {
    imprint: imprint,
  } satisfies UpdateFolderWatermarkRequestBodyWatermarkField;
}
export function serializeUpdateFolderWatermarkRequestBodyWatermarkFieldInput(
  val: UpdateFolderWatermarkRequestBodyWatermarkFieldInput,
): SerializedData {
  return {
    ['imprint']:
      val.imprint == void 0
        ? val.imprint
        : serializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
            val.imprint,
          ),
  };
}
export function deserializeUpdateFolderWatermarkRequestBodyWatermarkFieldInput(
  val: SerializedData,
): UpdateFolderWatermarkRequestBodyWatermarkFieldInput {
  if (!sdIsMap(val)) {
    throw new BoxSdkError({
      message:
        'Expecting a map for "UpdateFolderWatermarkRequestBodyWatermarkFieldInput"',
    });
  }
  const imprint:
    | undefined
    | UpdateFolderWatermarkRequestBodyWatermarkImprintField =
    val.imprint == void 0
      ? void 0
      : deserializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
          val.imprint,
        );
  return {
    imprint: imprint,
  } satisfies UpdateFolderWatermarkRequestBodyWatermarkFieldInput;
}
export function serializeUpdateFolderWatermarkRequestBody(
  val: UpdateFolderWatermarkRequestBody,
): SerializedData {
  return {
    ['watermark']: serializeUpdateFolderWatermarkRequestBodyWatermarkField(
      val.watermark,
    ),
  };
}
export function deserializeUpdateFolderWatermarkRequestBody(
  val: SerializedData,
): UpdateFolderWatermarkRequestBody {
  if (!sdIsMap(val)) {
    throw new BoxSdkError({
      message: 'Expecting a map for "UpdateFolderWatermarkRequestBody"',
    });
  }
  if (val.watermark == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "watermark" of type "UpdateFolderWatermarkRequestBody" to be defined',
    });
  }
  const watermark: UpdateFolderWatermarkRequestBodyWatermarkField =
    deserializeUpdateFolderWatermarkRequestBodyWatermarkField(val.watermark);
  return { watermark: watermark } satisfies UpdateFolderWatermarkRequestBody;
}

1	import { serializeWatermark } from '../schemas/watermark.generated.js';
2	import { deserializeWatermark } from '../schemas/watermark.generated.js';	144✔
3	import { serializeClientError } from '../schemas/clientError.generated.js';
4	import { deserializeClientError } from '../schemas/clientError.generated.js';
5	import { ResponseFormat } from '../networking/fetchOptions.generated.js';
6	import { Watermark } from '../schemas/watermark.generated.js';
7	import { ClientError } from '../schemas/clientError.generated.js';
8	import { BoxSdkError } from '../box/errors.js';	144✔
9	import { Authentication } from '../networking/auth.generated.js';
10	import { NetworkSession } from '../networking/network.generated.js';	144✔
11	import { FetchOptions } from '../networking/fetchOptions.generated.js';	144✔
12	import { FetchResponse } from '../networking/fetchResponse.generated.js';
13	import { prepareParams } from '../internal/utils.js';	144✔
14	import { toString } from '../internal/utils.js';	144✔
15	import { ByteStream } from '../internal/utils.js';
16	import { CancellationToken } from '../internal/utils.js';
17	import { sdToJson } from '../serialization/json.js';
18	import { SerializedData } from '../serialization/json.js';
19	import { sdIsEmpty } from '../serialization/json.js';
20	import { sdIsBoolean } from '../serialization/json.js';
21	import { sdIsNumber } from '../serialization/json.js';
22	import { sdIsString } from '../serialization/json.js';	144✔
23	import { sdIsList } from '../serialization/json.js';
24	import { sdIsMap } from '../serialization/json.js';	144✔
25	export class GetFolderWatermarkOptionals {	144✔
26	readonly headers: GetFolderWatermarkHeaders = new GetFolderWatermarkHeaders(	4✔
27	{},
28	);
29	readonly cancellationToken?: CancellationToken = void 0;	4✔
30	constructor(
31	fields: Omit<GetFolderWatermarkOptionals, 'headers' \| 'cancellationToken'> &
32	Partial<
33	Pick<GetFolderWatermarkOptionals, 'headers' \| 'cancellationToken'>
34	>,
35	) {
36	if (fields.headers !== undefined) {	4!
37	this.headers = fields.headers;	×
38	}
39	if (fields.cancellationToken !== undefined) {	4!
40	this.cancellationToken = fields.cancellationToken;	×
41	}
42	}
43	}
44	export interface GetFolderWatermarkOptionalsInput {
45	readonly headers?: GetFolderWatermarkHeaders;
46	readonly cancellationToken?: undefined \| CancellationToken;
47	}
48	export class UpdateFolderWatermarkOptionals {	144✔
49	readonly headers: UpdateFolderWatermarkHeaders =	2✔
50	new UpdateFolderWatermarkHeaders({});
51	readonly cancellationToken?: CancellationToken = void 0;	2✔
52	constructor(
53	fields: Omit<
54	UpdateFolderWatermarkOptionals,
55	'headers' \| 'cancellationToken'
56	> &
57	Partial<
58	Pick<UpdateFolderWatermarkOptionals, 'headers' \| 'cancellationToken'>
59	>,
60	) {
61	if (fields.headers !== undefined) {	2!
62	this.headers = fields.headers;	×
63	}
64	if (fields.cancellationToken !== undefined) {	2!
65	this.cancellationToken = fields.cancellationToken;	×
66	}
67	}
68	}
69	export interface UpdateFolderWatermarkOptionalsInput {
70	readonly headers?: UpdateFolderWatermarkHeaders;
71	readonly cancellationToken?: undefined \| CancellationToken;
72	}
73	export class DeleteFolderWatermarkOptionals {	144✔
74	readonly headers: DeleteFolderWatermarkHeaders =	2✔
75	new DeleteFolderWatermarkHeaders({});
76	readonly cancellationToken?: CancellationToken = void 0;	2✔
77	constructor(
78	fields: Omit<
79	DeleteFolderWatermarkOptionals,
80	'headers' \| 'cancellationToken'
81	> &
82	Partial<
83	Pick<DeleteFolderWatermarkOptionals, 'headers' \| 'cancellationToken'>
84	>,
85	) {
86	if (fields.headers !== undefined) {	2!
87	this.headers = fields.headers;	×
88	}
89	if (fields.cancellationToken !== undefined) {	2!
90	this.cancellationToken = fields.cancellationToken;	×
91	}
92	}
93	}
94	export interface DeleteFolderWatermarkOptionalsInput {
95	readonly headers?: DeleteFolderWatermarkHeaders;
96	readonly cancellationToken?: undefined \| CancellationToken;
97	}
98	export class GetFolderWatermarkHeaders {	144✔
99	/**
100	* Extra headers that will be included in the HTTP request. */
101	readonly extraHeaders?: {	4✔
102	readonly [key: string]: undefined \| string;
103	} = {};
104	constructor(
105	fields: Omit<GetFolderWatermarkHeaders, 'extraHeaders'> &
106	Partial<Pick<GetFolderWatermarkHeaders, 'extraHeaders'>>,
107	) {
108	if (fields.extraHeaders !== undefined) {	4!
109	this.extraHeaders = fields.extraHeaders;	×
110	}
111	}
112	}
113	export interface GetFolderWatermarkHeadersInput {
114	/**
115	* Extra headers that will be included in the HTTP request. */
116	readonly extraHeaders?:
117	\| undefined
118	\| {
119	readonly [key: string]: undefined \| string;
120	};
121	}
122	export type UpdateFolderWatermarkRequestBodyWatermarkImprintField =
123	\| 'default'
124	\| string;
125	export class UpdateFolderWatermarkRequestBodyWatermarkField {	144✔
126	/**
127	* The type of watermark to apply.
128	*
129	* Currently only supports one option. */
130	readonly imprint: UpdateFolderWatermarkRequestBodyWatermarkImprintField =	2✔
131	'default' as UpdateFolderWatermarkRequestBodyWatermarkImprintField;
132	readonly rawData?: SerializedData;
133	constructor(
134	fields: Omit<UpdateFolderWatermarkRequestBodyWatermarkField, 'imprint'> &
135	Partial<Pick<UpdateFolderWatermarkRequestBodyWatermarkField, 'imprint'>>,
136	) {
137	if (fields.imprint !== undefined) {	2✔
138	this.imprint = fields.imprint;	2✔
139	}
140	if (fields.rawData !== undefined) {	2!
141	this.rawData = fields.rawData;	×
142	}
143	}
144	}
145	export interface UpdateFolderWatermarkRequestBodyWatermarkFieldInput {
146	/**
147	* The type of watermark to apply.
148	*
149	* Currently only supports one option. */
150	readonly imprint?: UpdateFolderWatermarkRequestBodyWatermarkImprintField;
151	readonly rawData?: SerializedData;
152	}
153	export interface UpdateFolderWatermarkRequestBody {
154	/**
155	* The watermark to imprint on the folder */
156	readonly watermark: UpdateFolderWatermarkRequestBodyWatermarkField;
157	readonly rawData?: SerializedData;
158	}
159	export class UpdateFolderWatermarkHeaders {	144✔
160	/**
161	* Extra headers that will be included in the HTTP request. */
162	readonly extraHeaders?: {	2✔
163	readonly [key: string]: undefined \| string;
164	} = {};
165	constructor(
166	fields: Omit<UpdateFolderWatermarkHeaders, 'extraHeaders'> &
167	Partial<Pick<UpdateFolderWatermarkHeaders, 'extraHeaders'>>,
168	) {
169	if (fields.extraHeaders !== undefined) {	2!
170	this.extraHeaders = fields.extraHeaders;	×
171	}
172	}
173	}
174	export interface UpdateFolderWatermarkHeadersInput {
175	/**
176	* Extra headers that will be included in the HTTP request. */
177	readonly extraHeaders?:
178	\| undefined
179	\| {
180	readonly [key: string]: undefined \| string;
181	};
182	}
183	export class DeleteFolderWatermarkHeaders {	144✔
184	/**
185	* Extra headers that will be included in the HTTP request. */
186	readonly extraHeaders?: {	2✔
187	readonly [key: string]: undefined \| string;
188	} = {};
189	constructor(
190	fields: Omit<DeleteFolderWatermarkHeaders, 'extraHeaders'> &
191	Partial<Pick<DeleteFolderWatermarkHeaders, 'extraHeaders'>>,
192	) {
193	if (fields.extraHeaders !== undefined) {	2!
194	this.extraHeaders = fields.extraHeaders;	×
195	}
196	}
197	}
198	export interface DeleteFolderWatermarkHeadersInput {
199	/**
200	* Extra headers that will be included in the HTTP request. */
201	readonly extraHeaders?:
202	\| undefined
203	\| {
204	readonly [key: string]: undefined \| string;
205	};
206	}
207	export class FolderWatermarksManager {	144✔
208	readonly auth?: Authentication;
209	readonly networkSession: NetworkSession = new NetworkSession({});	312✔
210	constructor(
211	fields: Omit<
212	FolderWatermarksManager,
213	\| 'networkSession'
214	\| 'getFolderWatermark'
215	\| 'updateFolderWatermark'
216	\| 'deleteFolderWatermark'
217	> &
218	Partial<Pick<FolderWatermarksManager, 'networkSession'>>,
219	) {
220	if (fields.auth !== undefined) {	312✔
221	this.auth = fields.auth;	312✔
222	}
223	if (fields.networkSession !== undefined) {	312✔
224	this.networkSession = fields.networkSession;	312✔
225	}
226	}
227	/**
228	* Retrieve the watermark for a folder.
229	* @param {string} folderId The unique identifier that represent a folder.
230
231	The ID for any folder can be determined
232	by visiting this folder in the web application
233	and copying the ID from the URL. For example,
234	for the URL `https://*.app.box.com/folder/123`
235	the `folder_id` is `123`.
236
237	The root folder of a Box account is
238	always represented by the ID `0`.
239	Example: "12345"
240	* @param {GetFolderWatermarkOptionalsInput} optionalsInput
241	* @returns {Promise<Watermark>}
242	*/
243	async getFolderWatermark(
244	folderId: string,	4✔
245	optionalsInput: GetFolderWatermarkOptionalsInput = {},	4✔
246	): Promise<Watermark> {
247	const optionals: GetFolderWatermarkOptionals =
248	new GetFolderWatermarkOptionals({	4✔
249	headers: optionalsInput.headers,
250	cancellationToken: optionalsInput.cancellationToken,
251	});
252	const headers: any = optionals.headers;	4✔
253	const cancellationToken: any = optionals.cancellationToken;	4✔
254	const headersMap: {
255	readonly [key: string]: string;
256	} = prepareParams({ ...{}, ...headers.extraHeaders });	4✔
257	const response: FetchResponse =
258	await this.networkSession.networkClient.fetch(	4✔
259	new FetchOptions({
260	url: ''.concat(
261	this.networkSession.baseUrls.baseUrl,
262	'/2.0/folders/',
263	toString(folderId) as string,
264	'/watermark',
265	) as string,
266	method: 'GET',
267	headers: headersMap,
268	responseFormat: 'json' as ResponseFormat,
269	auth: this.auth,
270	networkSession: this.networkSession,
271	cancellationToken: cancellationToken,
272	}),
273	);
274	return {	2✔
275	...deserializeWatermark(response.data!),
276	rawData: response.data!,
277	};
278	}
279	/**
280	* Applies or update a watermark on a folder.
281	* @param {string} folderId The unique identifier that represent a folder.
282
283	The ID for any folder can be determined
284	by visiting this folder in the web application
285	and copying the ID from the URL. For example,
286	for the URL `https://*.app.box.com/folder/123`
287	the `folder_id` is `123`.
288
289	The root folder of a Box account is
290	always represented by the ID `0`.
291	Example: "12345"
292	* @param {UpdateFolderWatermarkRequestBody} requestBody Request body of updateFolderWatermark method
293	* @param {UpdateFolderWatermarkOptionalsInput} optionalsInput
294	* @returns {Promise<Watermark>}
295	*/
296	async updateFolderWatermark(
297	folderId: string,	2✔
298	requestBody: UpdateFolderWatermarkRequestBody,
299	optionalsInput: UpdateFolderWatermarkOptionalsInput = {},	2✔
300	): Promise<Watermark> {
301	const optionals: UpdateFolderWatermarkOptionals =
302	new UpdateFolderWatermarkOptionals({	2✔
303	headers: optionalsInput.headers,
304	cancellationToken: optionalsInput.cancellationToken,
305	});
306	const headers: any = optionals.headers;	2✔
307	const cancellationToken: any = optionals.cancellationToken;	2✔
308	const headersMap: {
309	readonly [key: string]: string;
310	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
311	const response: FetchResponse =
312	await this.networkSession.networkClient.fetch(	2✔
313	new FetchOptions({
314	url: ''.concat(
315	this.networkSession.baseUrls.baseUrl,
316	'/2.0/folders/',
317	toString(folderId) as string,
318	'/watermark',
319	) as string,
320	method: 'PUT',
321	headers: headersMap,
322	data: serializeUpdateFolderWatermarkRequestBody(requestBody),
323	contentType: 'application/json',
324	responseFormat: 'json' as ResponseFormat,
325	auth: this.auth,
326	networkSession: this.networkSession,
327	cancellationToken: cancellationToken,
328	}),
329	);
330	return {	2✔
331	...deserializeWatermark(response.data!),
332	rawData: response.data!,
333	};
334	}
335	/**
336	* Removes the watermark from a folder.
337	* @param {string} folderId The unique identifier that represent a folder.
338
339	The ID for any folder can be determined
340	by visiting this folder in the web application
341	and copying the ID from the URL. For example,
342	for the URL `https://*.app.box.com/folder/123`
343	the `folder_id` is `123`.
344
345	The root folder of a Box account is
346	always represented by the ID `0`.
347	Example: "12345"
348	* @param {DeleteFolderWatermarkOptionalsInput} optionalsInput
349	* @returns {Promise<undefined>}
350	*/
351	async deleteFolderWatermark(
352	folderId: string,	2✔
353	optionalsInput: DeleteFolderWatermarkOptionalsInput = {},	2✔
354	): Promise<undefined> {
355	const optionals: DeleteFolderWatermarkOptionals =
356	new DeleteFolderWatermarkOptionals({	2✔
357	headers: optionalsInput.headers,
358	cancellationToken: optionalsInput.cancellationToken,
359	});
360	const headers: any = optionals.headers;	2✔
361	const cancellationToken: any = optionals.cancellationToken;	2✔
362	const headersMap: {
363	readonly [key: string]: string;
364	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
365	const response: FetchResponse =
366	await this.networkSession.networkClient.fetch(	2✔
367	new FetchOptions({
368	url: ''.concat(
369	this.networkSession.baseUrls.baseUrl,
370	'/2.0/folders/',
371	toString(folderId) as string,
372	'/watermark',
373	) as string,
374	method: 'DELETE',
375	headers: headersMap,
376	responseFormat: 'no_content' as ResponseFormat,
377	auth: this.auth,
378	networkSession: this.networkSession,
379	cancellationToken: cancellationToken,
380	}),
381	);
382	return void 0;	2✔
383	}
384	}
385	export interface FolderWatermarksManagerInput {
386	readonly auth?: Authentication;
387	readonly networkSession?: NetworkSession;
388	}
389	export function serializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(	144✔
390	val: UpdateFolderWatermarkRequestBodyWatermarkImprintField,
391	): SerializedData {
392	return val;	2✔
393	}
394	export function deserializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(	144✔
395	val: SerializedData,
396	): UpdateFolderWatermarkRequestBodyWatermarkImprintField {
397	if (val == 'default') {	×
398	return val;	×
399	}
NEW 400	if (sdIsString(val)) {	×
NEW 401	return val;	×
402	}
403	throw new BoxSdkError({	×
404	message:
405	"Can't deserialize UpdateFolderWatermarkRequestBodyWatermarkImprintField",
406	});
407	}
408	export function serializeUpdateFolderWatermarkRequestBodyWatermarkField(	144✔
409	val: UpdateFolderWatermarkRequestBodyWatermarkField,
410	): SerializedData {
411	return {	2✔
412	['imprint']: serializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
413	val.imprint,
414	),
415	};
416	}
417	export function deserializeUpdateFolderWatermarkRequestBodyWatermarkField(	144✔
418	val: SerializedData,
419	): UpdateFolderWatermarkRequestBodyWatermarkField {
420	if (!sdIsMap(val)) {	×
421	throw new BoxSdkError({	×
422	message:
423	'Expecting a map for "UpdateFolderWatermarkRequestBodyWatermarkField"',
424	});
425	}
426	if (val.imprint == void 0) {	×
427	throw new BoxSdkError({	×
428	message:
429	'Expecting "imprint" of type "UpdateFolderWatermarkRequestBodyWatermarkField" to be defined',
430	});
431	}
432	const imprint: UpdateFolderWatermarkRequestBodyWatermarkImprintField =
433	deserializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(	×
434	val.imprint,
435	);
436	return {	×
437	imprint: imprint,
438	} satisfies UpdateFolderWatermarkRequestBodyWatermarkField;
439	}
440	export function serializeUpdateFolderWatermarkRequestBodyWatermarkFieldInput(	144✔
441	val: UpdateFolderWatermarkRequestBodyWatermarkFieldInput,
442	): SerializedData {
443	return {	×
444	['imprint']:
445	val.imprint == void 0	×
446	? val.imprint
447	: serializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
448	val.imprint,
449	),
450	};
451	}
452	export function deserializeUpdateFolderWatermarkRequestBodyWatermarkFieldInput(	144✔
453	val: SerializedData,
454	): UpdateFolderWatermarkRequestBodyWatermarkFieldInput {
455	if (!sdIsMap(val)) {	×
456	throw new BoxSdkError({	×
457	message:
458	'Expecting a map for "UpdateFolderWatermarkRequestBodyWatermarkFieldInput"',
459	});
460	}
461	const imprint:
462	\| undefined
463	\| UpdateFolderWatermarkRequestBodyWatermarkImprintField =
464	val.imprint == void 0	×
465	? void 0
466	: deserializeUpdateFolderWatermarkRequestBodyWatermarkImprintField(
467	val.imprint,
468	);
469	return {	×
470	imprint: imprint,
471	} satisfies UpdateFolderWatermarkRequestBodyWatermarkFieldInput;
472	}
473	export function serializeUpdateFolderWatermarkRequestBody(	144✔
474	val: UpdateFolderWatermarkRequestBody,
475	): SerializedData {
476	return {	2✔
477	['watermark']: serializeUpdateFolderWatermarkRequestBodyWatermarkField(
478	val.watermark,
479	),
480	};
481	}
482	export function deserializeUpdateFolderWatermarkRequestBody(	144✔
483	val: SerializedData,
484	): UpdateFolderWatermarkRequestBody {
485	if (!sdIsMap(val)) {	×
486	throw new BoxSdkError({	×
487	message: 'Expecting a map for "UpdateFolderWatermarkRequestBody"',
488	});
489	}
490	if (val.watermark == void 0) {	×
491	throw new BoxSdkError({	×
492	message:
493	'Expecting "watermark" of type "UpdateFolderWatermarkRequestBody" to be defined',
494	});
495	}
496	const watermark: UpdateFolderWatermarkRequestBodyWatermarkField =
497	deserializeUpdateFolderWatermarkRequestBodyWatermarkField(val.watermark);	×
498	return { watermark: watermark } satisfies UpdateFolderWatermarkRequestBody;	×
499	}

box / box-typescript-sdk-gen / 12870156465

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