box-node-sdk 3.8.2 → 4.0.0

package/lib/sdk-gen/managers/search.d.ts

@@ -0,0 +1,357 @@
+import { MetadataQueryResults } from '../schemas/metadataQueryResults';
+import { MetadataQuery } from '../schemas/metadataQuery';
+import { SearchResultsResponse } from '../schemas/searchResultsResponse';
+import { MetadataFilter } from '../schemas/metadataFilter';
+import { Authentication } from '../networking/auth';
+import { NetworkSession } from '../networking/network';
+import { CancellationToken } from '../internal/utils';
+import { SerializedData } from '../serialization/json';
+export declare class SearchByMetadataQueryOptionals {
+    readonly headers: SearchByMetadataQueryHeaders;
+    readonly cancellationToken?: CancellationToken;
+    constructor(fields: Omit<SearchByMetadataQueryOptionals, 'headers' | 'cancellationToken'> & Partial<Pick<SearchByMetadataQueryOptionals, 'headers' | 'cancellationToken'>>);
+}
+export interface SearchByMetadataQueryOptionalsInput {
+    readonly headers?: SearchByMetadataQueryHeaders;
+    readonly cancellationToken?: undefined | CancellationToken;
+}
+export declare class SearchByMetadataQueryHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    readonly extraHeaders?: {
+        readonly [key: string]: undefined | string;
+    };
+    constructor(fields: Omit<SearchByMetadataQueryHeaders, 'extraHeaders'> & Partial<Pick<SearchByMetadataQueryHeaders, 'extraHeaders'>>);
+}
+export interface SearchByMetadataQueryHeadersInput {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    readonly extraHeaders?: undefined | {
+        readonly [key: string]: undefined | string;
+    };
+}
+export type SearchForContentQueryParamsScopeField = 'user_content' | 'enterprise_content' | string;
+export type SearchForContentQueryParamsContentTypesField = 'name' | 'description' | 'file_content' | 'comments' | 'tag' | string;
+export type SearchForContentQueryParamsTypeField = 'file' | 'folder' | 'web_link';
+export type SearchForContentQueryParamsTrashContentField = 'non_trashed_only' | 'trashed_only' | 'all_items' | string;
+export type SearchForContentQueryParamsSortField = 'modified_at' | 'relevance' | string;
+export type SearchForContentQueryParamsDirectionField = 'DESC' | 'ASC' | string;
+export interface SearchForContentQueryParams {
+    /**
+     * The string to search for. This query is matched against item names,
+     * descriptions, text content of files, and various other fields of
+     * the different item types.
+     *
+     * This parameter supports a variety of operators to further refine
+     * the results returns.
+     *
+     * * `""` - by wrapping a query in double quotes only exact matches are
+     *   returned by the API. Exact searches do not return search matches
+     *   based on specific character sequences. Instead, they return
+     *   matches based on phrases, that is, word sequences. For example:
+     *   A search for `"Blue-Box"` may return search results including
+     *   the sequence `"blue.box"`, `"Blue Box"`, and `"Blue-Box"`;
+     *   any item containing the words `Blue` and `Box` consecutively, in
+     *   the order specified.
+     * * `AND` - returns items that contain both the search terms. For
+     *   example, a search for `marketing AND BoxWorks` returns items
+     *   that have both `marketing` and `BoxWorks` within its text in any order.
+     *   It does not return a result that only has `BoxWorks` in its text.
+     * * `OR` - returns items that contain either of the search terms. For
+     *   example, a search for `marketing OR BoxWorks` returns a result that
+     *   has either `marketing` or `BoxWorks` within its text. Using this
+     *   operator is not necessary as we implicitly interpret multi-word
+     *   queries as `OR` unless another supported boolean term is used.
+     * * `NOT` - returns items that do not contain the search term provided.
+     *   For example, a search for `marketing AND NOT BoxWorks` returns a result
+     *   that has only `marketing` within its text. Results containing
+     *   `BoxWorks` are omitted.
+     *
+     * We do not support lower case (that is,
+     * `and`, `or`, and `not`) or mixed case (that is, `And`, `Or`, and `Not`)
+     * operators.
+     *
+     * This field is required unless the `mdfilters` parameter is defined. */
+    readonly query?: string;
+    /**
+     * Limits the search results to either the files that the user has
+     * access to, or to files available to the entire enterprise.
+     *
+     * The scope defaults to `user_content`, which limits the search
+     * results to content that is available to the currently authenticated
+     * user.
+     *
+     * The `enterprise_content` can be requested by an admin through our
+     * support channels. Once this scope has been enabled for a user, it
+     * will allow that use to query for content across the entire
+     * enterprise and not only the content that they have access to. */
+    readonly scope?: SearchForContentQueryParamsScopeField;
+    /**
+     * Limits the search results to any files that match any of the provided
+     * file extensions. This list is a comma-separated list of file extensions
+     * without the dots. */
+    readonly fileExtensions?: readonly string[];
+    /**
+     * Limits the search results to any items created within
+     * a given date range.
+     *
+     * Date ranges are defined as comma separated RFC3339
+     * timestamps.
+     *
+     * If the start date is omitted (`,2014-05-17T13:35:01-07:00`)
+     * anything created before the end date will be returned.
+     *
+     * If the end date is omitted (`2014-05-15T13:35:01-07:00,`) the
+     * current date will be used as the end date instead. */
+    readonly createdAtRange?: readonly string[];
+    /**
+     * Limits the search results to any items updated within
+     * a given date range.
+     *
+     * Date ranges are defined as comma separated RFC3339
+     * timestamps.
+     *
+     * If the start date is omitted (`,2014-05-17T13:35:01-07:00`)
+     * anything updated before the end date will be returned.
+     *
+     * If the end date is omitted (`2014-05-15T13:35:01-07:00,`) the
+     * current date will be used as the end date instead. */
+    readonly updatedAtRange?: readonly string[];
+    /**
+     * Limits the search results to any items with a size within
+     * a given file size range. This applied to files and folders.
+     *
+     * Size ranges are defined as comma separated list of a lower
+     * and upper byte size limit (inclusive).
+     *
+     * The upper and lower bound can be omitted to create open ranges. */
+    readonly sizeRange?: readonly number[];
+    /**
+     * Limits the search results to any items that are owned
+     * by the given list of owners, defined as a list of comma separated
+     * user IDs.
+     *
+     * The items still need to be owned or shared with
+     * the currently authenticated user for them to show up in the search
+     * results. If the user does not have access to any files owned by any of
+     * the users an empty result set will be returned.
+     *
+     * To search across an entire enterprise, we recommend using the
+     * `enterprise_content` scope parameter which can be requested with our
+     * support team. */
+    readonly ownerUserIds?: readonly string[];
+    /**
+     * Limits the search results to any items that have been updated
+     * by the given list of users, defined as a list of comma separated
+     * user IDs.
+     *
+     * The items still need to be owned or shared with
+     * the currently authenticated user for them to show up in the search
+     * results. If the user does not have access to any files owned by any of
+     * the users an empty result set will be returned.
+     *
+     * This feature only searches back to the last 10 versions of an item. */
+    readonly recentUpdaterUserIds?: readonly string[];
+    /**
+     * Limits the search results to items within the given
+     * list of folders, defined as a comma separated lists
+     * of folder IDs.
+     *
+     * Search results will also include items within any subfolders
+     * of those ancestor folders.
+     *
+     * The folders still need to be owned or shared with
+     * the currently authenticated user. If the folder is not accessible by this
+     * user, or it does not exist, a `HTTP 404` error code will be returned
+     * instead.
+     *
+     * To search across an entire enterprise, we recommend using the
+     * `enterprise_content` scope parameter which can be requested with our
+     * support team. */
+    readonly ancestorFolderIds?: readonly string[];
+    /**
+     * Limits the search results to any items that match the search query
+     * for a specific part of the file, for example the file description.
+     *
+     * Content types are defined as a comma separated lists
+     * of Box recognized content types. The allowed content types are as follows.
+     *
+     * * `name` - The name of the item, as defined by its `name` field.
+     * * `description` - The description of the item, as defined by its
+     *   `description` field.
+     * * `file_content` - The actual content of the file.
+     * * `comments` - The content of any of the comments on a file or
+     *    folder.
+     * * `tags` - Any tags that are applied to an item, as defined by its
+     *    `tags` field. */
+    readonly contentTypes?: readonly SearchForContentQueryParamsContentTypesField[];
+    /**
+     * Limits the search results to any items of this type. This
+     * parameter only takes one value. By default the API returns
+     * items that match any of these types.
+     *
+     * * `file` - Limits the search results to files,
+     * * `folder` - Limits the search results to folders,
+     * * `web_link` - Limits the search results to web links, also known
+     *    as bookmarks. */
+    readonly type?: SearchForContentQueryParamsTypeField;
+    /**
+     * Determines if the search should look in the trash for items.
+     *
+     * By default, this API only returns search results for items
+     * not currently in the trash (`non_trashed_only`).
+     *
+     * * `trashed_only` - Only searches for items currently in the trash
+     * * `non_trashed_only` - Only searches for items currently not in
+     *   the trash
+     * * `all_items` - Searches for both trashed and non-trashed items. */
+    readonly trashContent?: SearchForContentQueryParamsTrashContentField;
+    /**
+     * Limits the search results to any items for which the metadata matches the provided filter.
+     * This parameter is a list that specifies exactly **one** metadata template used to filter the search results.
+     * The parameter is required unless the `query` parameter is provided. */
+    readonly mdfilters?: readonly MetadataFilter[];
+    /**
+     * Defines the order in which search results are returned. This API
+     * defaults to returning items by relevance unless this parameter is
+     * explicitly specified.
+     *
+     * * `relevance` (default) returns the results sorted by relevance to the
+     * query search term. The relevance is based on the occurrence of the search
+     * term in the items name, description, content, and additional properties.
+     * * `modified_at` returns the results ordered in descending order by date
+     * at which the item was last modified. */
+    readonly sort?: SearchForContentQueryParamsSortField;
+    /**
+     * Defines the direction in which search results are ordered. This API
+     * defaults to returning items in descending (`DESC`) order unless this
+     * parameter is explicitly specified.
+     *
+     * When results are sorted by `relevance` the ordering is locked to returning
+     * items in descending order of relevance, and this parameter is ignored. */
+    readonly direction?: SearchForContentQueryParamsDirectionField;
+    /**
+     * Defines the maximum number of items to return as part of a page of
+     * results. */
+    readonly limit?: number;
+    /**
+     * Defines whether the search results should include any items
+     * that the user recently accessed through a shared link.
+     *
+     * When this parameter has been set to true,
+     * the format of the response of this API changes to return
+     * a list of [Search Results with
+     * Shared Links](r://search_results_with_shared_links). */
+    readonly includeRecentSharedLinks?: boolean;
+    /**
+     * A comma-separated list of attributes to include in the
+     * response. This can be used to request fields that are
+     * not normally returned in a standard response.
+     *
+     * Be aware that specifying this parameter will have the
+     * effect that none of the standard fields are returned in
+     * the response unless explicitly specified, instead only
+     * fields for the mini representation are returned, additional
+     * to the fields requested. */
+    readonly fields?: readonly string[];
+    /**
+     * The offset of the item at which to begin the response.
+     *
+     * Queries with offset parameter value
+     * exceeding 10000 will be rejected
+     * with a 400 response. */
+    readonly offset?: number;
+    /**
+     * Limits the search results to items that were deleted by the given
+     * list of users, defined as a list of comma separated user IDs.
+     *
+     * The `trash_content` parameter needs to be set to `trashed_only`.
+     *
+     * If searching in trash is not performed, an empty result set
+     * is returned. The items need to be owned or shared with
+     * the currently authenticated user for them to show up in the search
+     * results.
+     *
+     * If the user does not have access to any files owned by
+     * any of the users, an empty result set is returned.
+     *
+     * Data available from 2023-02-01 onwards. */
+    readonly deletedUserIds?: readonly string[];
+    /**
+     * Limits the search results to any items deleted within a given
+     * date range.
+     *
+     * Date ranges are defined as comma separated RFC3339 timestamps.
+     *
+     * If the start date is omitted (`2014-05-17T13:35:01-07:00`),
+     * anything deleted before the end date will be returned.
+     *
+     * If the end date is omitted (`2014-05-15T13:35:01-07:00`),
+     * the current date will be used as the end date instead.
+     *
+     * The `trash_content` parameter needs to be set to `trashed_only`.
+     *
+     * If searching in trash is not performed, then an empty result
+     * is returned.
+     *
+     * Data available from 2023-02-01 onwards. */
+    readonly deletedAtRange?: readonly string[];
+}
+export declare class SearchForContentHeaders {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    readonly extraHeaders?: {
+        readonly [key: string]: undefined | string;
+    };
+    constructor(fields: Omit<SearchForContentHeaders, 'extraHeaders'> & Partial<Pick<SearchForContentHeaders, 'extraHeaders'>>);
+}
+export interface SearchForContentHeadersInput {
+    /**
+     * Extra headers that will be included in the HTTP request. */
+    readonly extraHeaders?: undefined | {
+        readonly [key: string]: undefined | string;
+    };
+}
+export declare class SearchManager {
+    readonly auth?: Authentication;
+    readonly networkSession: NetworkSession;
+    constructor(fields: Omit<SearchManager, 'networkSession' | 'searchByMetadataQuery' | 'searchForContent'> & Partial<Pick<SearchManager, 'networkSession'>>);
+    /**
+     * Create a search using SQL-like syntax to return items that match specific
+     * metadata.
+     *
+     * By default, this endpoint returns only the most basic info about the items for
+     * which the query matches. To get additional fields for each item, including any
+     * of the metadata, use the `fields` attribute in the query.
+     * @param {MetadataQuery} requestBody Request body of searchByMetadataQuery method
+     * @param {SearchByMetadataQueryOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataQueryResults>}
+     */
+    searchByMetadataQuery(requestBody: MetadataQuery, optionalsInput?: SearchByMetadataQueryOptionalsInput): Promise<MetadataQueryResults>;
+    /**
+     * Searches for files, folders, web links, and shared files across the
+     * users content or across the entire enterprise.
+     * @param {SearchForContentQueryParams} queryParams Query parameters of searchForContent method
+     * @param {SearchForContentHeadersInput} headersInput Headers of searchForContent method
+     * @param {CancellationToken} cancellationToken Token used for request cancellation.
+     * @returns {Promise<SearchResultsResponse>}
+     */
+    searchForContent(queryParams?: SearchForContentQueryParams, headersInput?: SearchForContentHeadersInput, cancellationToken?: CancellationToken): Promise<SearchResultsResponse>;
+}
+export interface SearchManagerInput {
+    readonly auth?: Authentication;
+    readonly networkSession?: NetworkSession;
+}
+export declare function serializeSearchForContentQueryParamsScopeField(val: SearchForContentQueryParamsScopeField): SerializedData;
+export declare function deserializeSearchForContentQueryParamsScopeField(val: SerializedData): SearchForContentQueryParamsScopeField;
+export declare function serializeSearchForContentQueryParamsContentTypesField(val: SearchForContentQueryParamsContentTypesField): SerializedData;
+export declare function deserializeSearchForContentQueryParamsContentTypesField(val: SerializedData): SearchForContentQueryParamsContentTypesField;
+export declare function serializeSearchForContentQueryParamsTypeField(val: SearchForContentQueryParamsTypeField): SerializedData;
+export declare function deserializeSearchForContentQueryParamsTypeField(val: SerializedData): SearchForContentQueryParamsTypeField;
+export declare function serializeSearchForContentQueryParamsTrashContentField(val: SearchForContentQueryParamsTrashContentField): SerializedData;
+export declare function deserializeSearchForContentQueryParamsTrashContentField(val: SerializedData): SearchForContentQueryParamsTrashContentField;
+export declare function serializeSearchForContentQueryParamsSortField(val: SearchForContentQueryParamsSortField): SerializedData;
+export declare function deserializeSearchForContentQueryParamsSortField(val: SerializedData): SearchForContentQueryParamsSortField;
+export declare function serializeSearchForContentQueryParamsDirectionField(val: SearchForContentQueryParamsDirectionField): SerializedData;
+export declare function deserializeSearchForContentQueryParamsDirectionField(val: SerializedData): SearchForContentQueryParamsDirectionField;
+//# sourceMappingURL=search.d.ts.map

package/lib/sdk-gen/managers/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/sdk-gen/managers/search.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAMvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAQvD,qBAAa,8BAA8B;IACzC,QAAQ,CAAC,OAAO,EAAE,4BAA4B,CACP;IACvC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAU;gBAEtD,MAAM,EAAE,IAAI,CACV,8BAA8B,EAC9B,SAAS,GAAG,mBAAmB,CAChC,GACC,OAAO,CACL,IAAI,CAAC,8BAA8B,EAAE,SAAS,GAAG,mBAAmB,CAAC,CACtE;CASN;AACD,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,4BAA4B,CAAC;IAChD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,GAAG,iBAAiB,CAAC;CAC5D;AACD,qBAAa,4BAA4B;IACvC;kEAC8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE;QACtB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;KAC5C,CAAM;gBAEL,MAAM,EAAE,IAAI,CAAC,4BAA4B,EAAE,cAAc,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,4BAA4B,EAAE,cAAc,CAAC,CAAC;CAMhE;AACD,MAAM,WAAW,iCAAiC;IAChD;kEAC8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAClB,SAAS,GACT;QACE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;KAC5C,CAAC;CACP;AACD,MAAM,MAAM,qCAAqC,GAC7C,cAAc,GACd,oBAAoB,GACpB,MAAM,CAAC;AACX,MAAM,MAAM,4CAA4C,GACpD,MAAM,GACN,aAAa,GACb,cAAc,GACd,UAAU,GACV,KAAK,GACL,MAAM,CAAC;AACX,MAAM,MAAM,oCAAoC,GAC5C,MAAM,GACN,QAAQ,GACR,UAAU,CAAC;AACf,MAAM,MAAM,4CAA4C,GACpD,kBAAkB,GAClB,cAAc,GACd,WAAW,GACX,MAAM,CAAC;AACX,MAAM,MAAM,oCAAoC,GAC5C,aAAa,GACb,WAAW,GACX,MAAM,CAAC;AACX,MAAM,MAAM,yCAAyC,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;AAChF,MAAM,WAAW,2BAA2B;IAC1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAkCyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;uEAWmE;IACnE,QAAQ,CAAC,KAAK,CAAC,EAAE,qCAAqC,CAAC;IACvD;;;2BAGuB;IACvB,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;;;;;;;;4DAWwD;IACxD,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;;;;;;;;4DAWwD;IACxD,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;;;;yEAOqE;IACrE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;;;;;;;;;;uBAYmB;IACnB,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;;;;;;;;6EAUyE;IACzE,QAAQ,CAAC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClD;;;;;;;;;;;;;;;uBAemB;IACnB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C;;;;;;;;;;;;;;0BAcsB;IACtB,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,4CAA4C,EAAE,CAAC;IAChF;;;;;;;;0BAQsB;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,oCAAoC,CAAC;IACrD;;;;;;;;;0EASsE;IACtE,QAAQ,CAAC,YAAY,CAAC,EAAE,4CAA4C,CAAC;IACrE;;;6EAGyE;IACzE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC/C;;;;;;;;;8CAS0C;IAC1C,QAAQ,CAAC,IAAI,CAAC,EAAE,oCAAoC,CAAC;IACrD;;;;;;gFAM4E;IAC5E,QAAQ,CAAC,SAAS,CAAC,EAAE,yCAAyC,CAAC;IAC/D;;kBAEc;IACd,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;8DAO0D;IAC1D,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C;;;;;;;;;kCAS8B;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;;;8BAK0B;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;;;;iDAc6C;IAC7C,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;;;;;;;;;;;;;;iDAiB6C;IAC7C,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7C;AACD,qBAAa,uBAAuB;IAClC;kEAC8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE;QACtB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;KAC5C,CAAM;gBAEL,MAAM,EAAE,IAAI,CAAC,uBAAuB,EAAE,cAAc,CAAC,GACnD,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,cAAc,CAAC,CAAC;CAM3D;AACD,MAAM,WAAW,4BAA4B;IAC3C;kEAC8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAClB,SAAS,GACT;QACE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;KAC5C,CAAC;CACP;AACD,qBAAa,aAAa;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,cAAc,CAA0B;gBAE/D,MAAM,EAAE,IAAI,CACV,aAAa,EACb,gBAAgB,GAAG,uBAAuB,GAAG,kBAAkB,CAChE,GACC,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC;IASlD;;;;;;;;;;OAUG;IACG,qBAAqB,CACzB,WAAW,EAAE,aAAa,EAC1B,cAAc,GAAE,mCAAwC,GACvD,OAAO,CAAC,oBAAoB,CAAC;IAiChC;;;;;;;OAOG;IACG,gBAAgB,CACpB,WAAW,GAAE,2BAAsE,EACnF,YAAY,GAAE,4BAEb,EACD,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,OAAO,CAAC,qBAAqB,CAAC;CA+ElC;AACD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;CAC1C;AACD,wBAAgB,8CAA8C,CAC5D,GAAG,EAAE,qCAAqC,GACzC,cAAc,CAEhB;AACD,wBAAgB,gDAAgD,CAC9D,GAAG,EAAE,cAAc,GAClB,qCAAqC,CAavC;AACD,wBAAgB,qDAAqD,CACnE,GAAG,EAAE,4CAA4C,GAChD,cAAc,CAEhB;AACD,wBAAgB,uDAAuD,CACrE,GAAG,EAAE,cAAc,GAClB,4CAA4C,CAsB9C;AACD,wBAAgB,6CAA6C,CAC3D,GAAG,EAAE,oCAAoC,GACxC,cAAc,CAEhB;AACD,wBAAgB,+CAA+C,CAC7D,GAAG,EAAE,cAAc,GAClB,oCAAoC,CAatC;AACD,wBAAgB,qDAAqD,CACnE,GAAG,EAAE,4CAA4C,GAChD,cAAc,CAEhB;AACD,wBAAgB,uDAAuD,CACrE,GAAG,EAAE,cAAc,GAClB,4CAA4C,CAgB9C;AACD,wBAAgB,6CAA6C,CAC3D,GAAG,EAAE,oCAAoC,GACxC,cAAc,CAEhB;AACD,wBAAgB,+CAA+C,CAC7D,GAAG,EAAE,cAAc,GAClB,oCAAoC,CAatC;AACD,wBAAgB,kDAAkD,CAChE,GAAG,EAAE,yCAAyC,GAC7C,cAAc,CAEhB;AACD,wBAAgB,oDAAoD,CAClE,GAAG,EAAE,cAAc,GAClB,yCAAyC,CAa3C"}

package/lib/sdk-gen/managers/search.js

@@ -0,0 +1,305 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchManager = exports.SearchForContentHeaders = exports.SearchByMetadataQueryHeaders = exports.SearchByMetadataQueryOptionals = void 0;
+exports.serializeSearchForContentQueryParamsScopeField = serializeSearchForContentQueryParamsScopeField;
+exports.deserializeSearchForContentQueryParamsScopeField = deserializeSearchForContentQueryParamsScopeField;
+exports.serializeSearchForContentQueryParamsContentTypesField = serializeSearchForContentQueryParamsContentTypesField;
+exports.deserializeSearchForContentQueryParamsContentTypesField = deserializeSearchForContentQueryParamsContentTypesField;
+exports.serializeSearchForContentQueryParamsTypeField = serializeSearchForContentQueryParamsTypeField;
+exports.deserializeSearchForContentQueryParamsTypeField = deserializeSearchForContentQueryParamsTypeField;
+exports.serializeSearchForContentQueryParamsTrashContentField = serializeSearchForContentQueryParamsTrashContentField;
+exports.deserializeSearchForContentQueryParamsTrashContentField = deserializeSearchForContentQueryParamsTrashContentField;
+exports.serializeSearchForContentQueryParamsSortField = serializeSearchForContentQueryParamsSortField;
+exports.deserializeSearchForContentQueryParamsSortField = deserializeSearchForContentQueryParamsSortField;
+exports.serializeSearchForContentQueryParamsDirectionField = serializeSearchForContentQueryParamsDirectionField;
+exports.deserializeSearchForContentQueryParamsDirectionField = deserializeSearchForContentQueryParamsDirectionField;
+const metadataQueryResults_1 = require("../schemas/metadataQueryResults");
+const metadataQuery_1 = require("../schemas/metadataQuery");
+const searchResultsResponse_1 = require("../schemas/searchResultsResponse");
+const metadataFilter_1 = require("../schemas/metadataFilter");
+const errors_1 = require("../box/errors");
+const network_1 = require("../networking/network");
+const fetchOptions_1 = require("../networking/fetchOptions");
+const utils_1 = require("../internal/utils");
+const utils_2 = require("../internal/utils");
+const json_1 = require("../serialization/json");
+const json_2 = require("../serialization/json");
+class SearchByMetadataQueryOptionals {
+    constructor(fields) {
+        this.headers = new SearchByMetadataQueryHeaders({});
+        this.cancellationToken = void 0;
+        if (fields.headers !== undefined) {
+            this.headers = fields.headers;
+        }
+        if (fields.cancellationToken !== undefined) {
+            this.cancellationToken = fields.cancellationToken;
+        }
+    }
+}
+exports.SearchByMetadataQueryOptionals = SearchByMetadataQueryOptionals;
+class SearchByMetadataQueryHeaders {
+    constructor(fields) {
+        /**
+         * Extra headers that will be included in the HTTP request. */
+        this.extraHeaders = {};
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+exports.SearchByMetadataQueryHeaders = SearchByMetadataQueryHeaders;
+class SearchForContentHeaders {
+    constructor(fields) {
+        /**
+         * Extra headers that will be included in the HTTP request. */
+        this.extraHeaders = {};
+        if (fields.extraHeaders !== undefined) {
+            this.extraHeaders = fields.extraHeaders;
+        }
+    }
+}
+exports.SearchForContentHeaders = SearchForContentHeaders;
+class SearchManager {
+    constructor(fields) {
+        this.networkSession = new network_1.NetworkSession({});
+        if (fields.auth !== undefined) {
+            this.auth = fields.auth;
+        }
+        if (fields.networkSession !== undefined) {
+            this.networkSession = fields.networkSession;
+        }
+    }
+    /**
+     * Create a search using SQL-like syntax to return items that match specific
+     * metadata.
+     *
+     * By default, this endpoint returns only the most basic info about the items for
+     * which the query matches. To get additional fields for each item, including any
+     * of the metadata, use the `fields` attribute in the query.
+     * @param {MetadataQuery} requestBody Request body of searchByMetadataQuery method
+     * @param {SearchByMetadataQueryOptionalsInput} optionalsInput
+     * @returns {Promise<MetadataQueryResults>}
+     */
+    searchByMetadataQuery(requestBody_1) {
+        return __awaiter(this, arguments, void 0, function* (requestBody, optionalsInput = {}) {
+            const optionals = new SearchByMetadataQueryOptionals({
+                headers: optionalsInput.headers,
+                cancellationToken: optionalsInput.cancellationToken,
+            });
+            const headers = optionals.headers;
+            const cancellationToken = optionals.cancellationToken;
+            const headersMap = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
+            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
+                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/metadata_queries/execute_read'),
+                method: 'POST',
+                headers: headersMap,
+                data: (0, metadataQuery_1.serializeMetadataQuery)(requestBody),
+                contentType: 'application/json',
+                responseFormat: 'json',
+                auth: this.auth,
+                networkSession: this.networkSession,
+                cancellationToken: cancellationToken,
+            }));
+            return Object.assign(Object.assign({}, (0, metadataQueryResults_1.deserializeMetadataQueryResults)(response.data)), { rawData: response.data });
+        });
+    }
+    /**
+     * Searches for files, folders, web links, and shared files across the
+     * users content or across the entire enterprise.
+     * @param {SearchForContentQueryParams} queryParams Query parameters of searchForContent method
+     * @param {SearchForContentHeadersInput} headersInput Headers of searchForContent method
+     * @param {CancellationToken} cancellationToken Token used for request cancellation.
+     * @returns {Promise<SearchResultsResponse>}
+     */
+    searchForContent() {
+        return __awaiter(this, arguments, void 0, function* (queryParams = {}, headersInput = new SearchForContentHeaders({}), cancellationToken) {
+            const headers = new SearchForContentHeaders({
+                extraHeaders: headersInput.extraHeaders,
+            });
+            const queryParamsMap = (0, utils_1.prepareParams)({
+                ['query']: (0, utils_2.toString)(queryParams.query),
+                ['scope']: (0, utils_2.toString)(queryParams.scope),
+                ['file_extensions']: queryParams.fileExtensions
+                    ? queryParams.fileExtensions.map(utils_2.toString).join(',')
+                    : undefined,
+                ['created_at_range']: queryParams.createdAtRange
+                    ? queryParams.createdAtRange.map(utils_2.toString).join(',')
+                    : undefined,
+                ['updated_at_range']: queryParams.updatedAtRange
+                    ? queryParams.updatedAtRange.map(utils_2.toString).join(',')
+                    : undefined,
+                ['size_range']: queryParams.sizeRange
+                    ? queryParams.sizeRange.map(utils_2.toString).join(',')
+                    : undefined,
+                ['owner_user_ids']: queryParams.ownerUserIds
+                    ? queryParams.ownerUserIds.map(utils_2.toString).join(',')
+                    : undefined,
+                ['recent_updater_user_ids']: queryParams.recentUpdaterUserIds
+                    ? queryParams.recentUpdaterUserIds.map(utils_2.toString).join(',')
+                    : undefined,
+                ['ancestor_folder_ids']: queryParams.ancestorFolderIds
+                    ? queryParams.ancestorFolderIds.map(utils_2.toString).join(',')
+                    : undefined,
+                ['content_types']: queryParams.contentTypes
+                    ? queryParams.contentTypes.map(utils_2.toString).join(',')
+                    : undefined,
+                ['type']: (0, utils_2.toString)(queryParams.type),
+                ['trash_content']: (0, utils_2.toString)(queryParams.trashContent),
+                ['mdfilters']: queryParams.mdfilters
+                    ? (0, json_1.sdToJson)(queryParams.mdfilters.map(metadataFilter_1.serializeMetadataFilter))
+                    : undefined,
+                ['sort']: (0, utils_2.toString)(queryParams.sort),
+                ['direction']: (0, utils_2.toString)(queryParams.direction),
+                ['limit']: (0, utils_2.toString)(queryParams.limit),
+                ['include_recent_shared_links']: (0, utils_2.toString)(queryParams.includeRecentSharedLinks),
+                ['fields']: queryParams.fields
+                    ? queryParams.fields.map(utils_2.toString).join(',')
+                    : undefined,
+                ['offset']: (0, utils_2.toString)(queryParams.offset),
+                ['deleted_user_ids']: queryParams.deletedUserIds
+                    ? queryParams.deletedUserIds.map(utils_2.toString).join(',')
+                    : undefined,
+                ['deleted_at_range']: queryParams.deletedAtRange
+                    ? queryParams.deletedAtRange.map(utils_2.toString).join(',')
+                    : undefined,
+            });
+            const headersMap = (0, utils_1.prepareParams)(Object.assign({}, headers.extraHeaders));
+            const response = yield this.networkSession.networkClient.fetch(new fetchOptions_1.FetchOptions({
+                url: ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/search'),
+                method: 'GET',
+                params: queryParamsMap,
+                headers: headersMap,
+                responseFormat: 'json',
+                auth: this.auth,
+                networkSession: this.networkSession,
+                cancellationToken: cancellationToken,
+            }));
+            return Object.assign(Object.assign({}, (0, searchResultsResponse_1.deserializeSearchResultsResponse)(response.data)), { rawData: response.data });
+        });
+    }
+}
+exports.SearchManager = SearchManager;
+function serializeSearchForContentQueryParamsScopeField(val) {
+    return val;
+}
+function deserializeSearchForContentQueryParamsScopeField(val) {
+    if (val == 'user_content') {
+        return val;
+    }
+    if (val == 'enterprise_content') {
+        return val;
+    }
+    if ((0, json_2.sdIsString)(val)) {
+        return val;
+    }
+    throw new errors_1.BoxSdkError({
+        message: "Can't deserialize SearchForContentQueryParamsScopeField",
+    });
+}
+function serializeSearchForContentQueryParamsContentTypesField(val) {
+    return val;
+}
+function deserializeSearchForContentQueryParamsContentTypesField(val) {
+    if (val == 'name') {
+        return val;
+    }
+    if (val == 'description') {
+        return val;
+    }
+    if (val == 'file_content') {
+        return val;
+    }
+    if (val == 'comments') {
+        return val;
+    }
+    if (val == 'tag') {
+        return val;
+    }
+    if ((0, json_2.sdIsString)(val)) {
+        return val;
+    }
+    throw new errors_1.BoxSdkError({
+        message: "Can't deserialize SearchForContentQueryParamsContentTypesField",
+    });
+}
+function serializeSearchForContentQueryParamsTypeField(val) {
+    return val;
+}
+function deserializeSearchForContentQueryParamsTypeField(val) {
+    if (val == 'file') {
+        return val;
+    }
+    if (val == 'folder') {
+        return val;
+    }
+    if (val == 'web_link') {
+        return val;
+    }
+    throw new errors_1.BoxSdkError({
+        message: "Can't deserialize SearchForContentQueryParamsTypeField",
+    });
+}
+function serializeSearchForContentQueryParamsTrashContentField(val) {
+    return val;
+}
+function deserializeSearchForContentQueryParamsTrashContentField(val) {
+    if (val == 'non_trashed_only') {
+        return val;
+    }
+    if (val == 'trashed_only') {
+        return val;
+    }
+    if (val == 'all_items') {
+        return val;
+    }
+    if ((0, json_2.sdIsString)(val)) {
+        return val;
+    }
+    throw new errors_1.BoxSdkError({
+        message: "Can't deserialize SearchForContentQueryParamsTrashContentField",
+    });
+}
+function serializeSearchForContentQueryParamsSortField(val) {
+    return val;
+}
+function deserializeSearchForContentQueryParamsSortField(val) {
+    if (val == 'modified_at') {
+        return val;
+    }
+    if (val == 'relevance') {
+        return val;
+    }
+    if ((0, json_2.sdIsString)(val)) {
+        return val;
+    }
+    throw new errors_1.BoxSdkError({
+        message: "Can't deserialize SearchForContentQueryParamsSortField",
+    });
+}
+function serializeSearchForContentQueryParamsDirectionField(val) {
+    return val;
+}
+function deserializeSearchForContentQueryParamsDirectionField(val) {
+    if (val == 'DESC') {
+        return val;
+    }
+    if (val == 'ASC') {
+        return val;
+    }
+    if ((0, json_2.sdIsString)(val)) {
+        return val;
+    }
+    throw new errors_1.BoxSdkError({
+        message: "Can't deserialize SearchForContentQueryParamsDirectionField",
+    });
+}
+//# sourceMappingURL=search.js.map