@redis/search 1.0.6

package/dist/commands/EXPLAINCLI.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.IS_READ_ONLY = void 0;
+exports.IS_READ_ONLY = true;
+function transformArguments(index, query) {
+    return ['FT.EXPLAINCLI', index, query];
+}
+exports.transformArguments = transformArguments;

package/dist/commands/INFO.d.ts

@@ -0,0 +1,120 @@
+import { RedisCommandArgument } from '@redis/client/dist/lib/commands';
+export declare function transformArguments(index: string): Array<string>;
+declare type InfoRawReply = [
+    'index_name',
+    RedisCommandArgument,
+    'index_options',
+    Array<RedisCommandArgument>,
+    'index_definition',
+    Array<RedisCommandArgument>,
+    'attributes',
+    Array<Array<RedisCommandArgument>>,
+    'num_docs',
+    RedisCommandArgument,
+    'max_doc_id',
+    RedisCommandArgument,
+    'num_terms',
+    RedisCommandArgument,
+    'num_records',
+    RedisCommandArgument,
+    'inverted_sz_mb',
+    RedisCommandArgument,
+    'vector_index_sz_mb',
+    RedisCommandArgument,
+    'total_inverted_index_blocks',
+    RedisCommandArgument,
+    'offset_vectors_sz_mb',
+    RedisCommandArgument,
+    'doc_table_size_mb',
+    RedisCommandArgument,
+    'sortable_values_size_mb',
+    RedisCommandArgument,
+    'key_table_size_mb',
+    RedisCommandArgument,
+    'records_per_doc_avg',
+    RedisCommandArgument,
+    'bytes_per_record_avg',
+    RedisCommandArgument,
+    'offsets_per_term_avg',
+    RedisCommandArgument,
+    'offset_bits_per_record_avg',
+    RedisCommandArgument,
+    'hash_indexing_failures',
+    RedisCommandArgument,
+    'indexing',
+    RedisCommandArgument,
+    'percent_indexed',
+    RedisCommandArgument,
+    'gc_stats',
+    [
+        'bytes_collected',
+        RedisCommandArgument,
+        'total_ms_run',
+        RedisCommandArgument,
+        'total_cycles',
+        RedisCommandArgument,
+        'average_cycle_time_ms',
+        RedisCommandArgument,
+        'last_run_time_ms',
+        RedisCommandArgument,
+        'gc_numeric_trees_missed',
+        RedisCommandArgument,
+        'gc_blocks_denied',
+        RedisCommandArgument
+    ],
+    'cursor_stats',
+    [
+        'global_idle',
+        number,
+        'global_total',
+        number,
+        'index_capacity',
+        number,
+        'index_total',
+        number
+    ],
+    'stopwords_list'?,
+    Array<RedisCommandArgument>?
+];
+interface InfoReply {
+    indexName: RedisCommandArgument;
+    indexOptions: Array<RedisCommandArgument>;
+    indexDefinition: Record<string, RedisCommandArgument>;
+    attributes: Array<Record<string, RedisCommandArgument>>;
+    numDocs: RedisCommandArgument;
+    maxDocId: RedisCommandArgument;
+    numTerms: RedisCommandArgument;
+    numRecords: RedisCommandArgument;
+    invertedSzMb: RedisCommandArgument;
+    vectorIndexSzMb: RedisCommandArgument;
+    totalInvertedIndexBlocks: RedisCommandArgument;
+    offsetVectorsSzMb: RedisCommandArgument;
+    docTableSizeMb: RedisCommandArgument;
+    sortableValuesSizeMb: RedisCommandArgument;
+    keyTableSizeMb: RedisCommandArgument;
+    recordsPerDocAvg: RedisCommandArgument;
+    bytesPerRecordAvg: RedisCommandArgument;
+    offsetsPerTermAvg: RedisCommandArgument;
+    offsetBitsPerRecordAvg: RedisCommandArgument;
+    hashIndexingFailures: RedisCommandArgument;
+    indexing: RedisCommandArgument;
+    percentIndexed: RedisCommandArgument;
+    gcStats: {
+        bytesCollected: RedisCommandArgument;
+        totalMsRun: RedisCommandArgument;
+        totalCycles: RedisCommandArgument;
+        averageCycleTimeMs: RedisCommandArgument;
+        lastRunTimeMs: RedisCommandArgument;
+        gcNumericTreesMissed: RedisCommandArgument;
+        gcBlocksDenied: RedisCommandArgument;
+    };
+    cursorStats: {
+        globalIdle: number;
+        globalTotal: number;
+        indexCapacity: number;
+        idnexTotal: number;
+    };
+    stopWords: Array<RedisCommandArgument> | undefined;
+}
+export declare function transformReply(rawReply: InfoRawReply): InfoReply;
+export {};

package/dist/commands/INFO.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+function transformArguments(index) {
+    return ['FT.INFO', index];
+}
+exports.transformArguments = transformArguments;
+function transformReply(rawReply) {
+    return {
+        indexName: rawReply[1],
+        indexOptions: rawReply[3],
+        indexDefinition: (0, generic_transformers_1.transformTuplesReply)(rawReply[5]),
+        attributes: rawReply[7].map(attribute => (0, generic_transformers_1.transformTuplesReply)(attribute)),
+        numDocs: rawReply[9],
+        maxDocId: rawReply[11],
+        numTerms: rawReply[13],
+        numRecords: rawReply[15],
+        invertedSzMb: rawReply[17],
+        vectorIndexSzMb: rawReply[19],
+        totalInvertedIndexBlocks: rawReply[21],
+        offsetVectorsSzMb: rawReply[23],
+        docTableSizeMb: rawReply[25],
+        sortableValuesSizeMb: rawReply[27],
+        keyTableSizeMb: rawReply[29],
+        recordsPerDocAvg: rawReply[31],
+        bytesPerRecordAvg: rawReply[33],
+        offsetsPerTermAvg: rawReply[35],
+        offsetBitsPerRecordAvg: rawReply[37],
+        hashIndexingFailures: rawReply[39],
+        indexing: rawReply[41],
+        percentIndexed: rawReply[43],
+        gcStats: {
+            bytesCollected: rawReply[45][1],
+            totalMsRun: rawReply[45][3],
+            totalCycles: rawReply[45][5],
+            averageCycleTimeMs: rawReply[45][7],
+            lastRunTimeMs: rawReply[45][9],
+            gcNumericTreesMissed: rawReply[45][11],
+            gcBlocksDenied: rawReply[45][13]
+        },
+        cursorStats: {
+            globalIdle: rawReply[47][1],
+            globalTotal: rawReply[47][3],
+            indexCapacity: rawReply[47][5],
+            idnexTotal: rawReply[47][7]
+        },
+        stopWords: rawReply[49]
+    };
+}
+exports.transformReply = transformReply;

package/dist/commands/PROFILE_AGGREGATE.d.ts

@@ -0,0 +1,7 @@
+import { AggregateOptions, AggregateRawReply } from './AGGREGATE';
+import { ProfileOptions, ProfileRawReply, ProfileReply } from '.';
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(index: string, query: string, options?: ProfileOptions & AggregateOptions): Array<string>;
+declare type ProfileAggeregateRawReply = ProfileRawReply<AggregateRawReply>;
+export declare function transformReply(reply: ProfileAggeregateRawReply): ProfileReply;
+export {};

package/dist/commands/PROFILE_AGGREGATE.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const AGGREGATE_1 = require("./AGGREGATE");
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(index, query, options) {
+    const args = ['FT.PROFILE', index, 'AGGREGATE'];
+    if (options?.LIMITED) {
+        args.push('LIMITED');
+    }
+    args.push('QUERY', query);
+    (0, AGGREGATE_1.pushAggregatehOptions)(args, options);
+    return args;
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    return {
+        results: (0, AGGREGATE_1.transformReply)(reply[0]),
+        profile: (0, _1.transformProfile)(reply[1])
+    };
+}
+exports.transformReply = transformReply;

package/dist/commands/PROFILE_SEARCH.d.ts

@@ -0,0 +1,8 @@
+import { SearchOptions, SearchRawReply } from './SEARCH';
+import { ProfileOptions, ProfileRawReply, ProfileReply } from '.';
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(index: string, query: string, options?: ProfileOptions & SearchOptions): RedisCommandArguments;
+declare type ProfileSearchRawReply = ProfileRawReply<SearchRawReply>;
+export declare function transformReply(reply: ProfileSearchRawReply): ProfileReply;
+export {};

package/dist/commands/PROFILE_SEARCH.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const SEARCH_1 = require("./SEARCH");
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(index, query, options) {
+    const args = ['FT.PROFILE', index, 'SEARCH'];
+    if (options?.LIMITED) {
+        args.push('LIMITED');
+    }
+    args.push('QUERY', query);
+    return (0, _1.pushSearchOptions)(args, options);
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    return {
+        results: (0, SEARCH_1.transformReply)(reply[0]),
+        profile: (0, _1.transformProfile)(reply[1])
+    };
+}
+exports.transformReply = transformReply;

package/dist/commands/SEARCH.d.ts

@@ -0,0 +1,40 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { RedisSearchLanguages, Params, PropertyName, SortByProperty, SearchReply } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare const IS_READ_ONLY = true;
+export interface SearchOptions {
+    VERBATIM?: true;
+    NOSTOPWORDS?: true;
+    WITHSORTKEYS?: true;
+    INKEYS?: string | Array<string>;
+    INFIELDS?: string | Array<string>;
+    RETURN?: string | Array<string>;
+    SUMMARIZE?: true | {
+        FIELDS?: PropertyName | Array<PropertyName>;
+        FRAGS?: number;
+        LEN?: number;
+        SEPARATOR?: string;
+    };
+    HIGHLIGHT?: true | {
+        FIELDS?: PropertyName | Array<PropertyName>;
+        TAGS?: {
+            open: string;
+            close: string;
+        };
+    };
+    SLOP?: number;
+    INORDER?: true;
+    LANGUAGE?: RedisSearchLanguages;
+    EXPANDER?: string;
+    SCORER?: string;
+    SORTBY?: SortByProperty;
+    LIMIT?: {
+        from: number | string;
+        size: number | string;
+    };
+    PARAMS?: Params;
+    DIALECT?: number;
+}
+export declare function transformArguments(index: string, query: string, options?: SearchOptions): RedisCommandArguments;
+export declare type SearchRawReply = Array<any>;
+export declare function transformReply(reply: SearchRawReply): SearchReply;

package/dist/commands/SEARCH.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+exports.IS_READ_ONLY = true;
+function transformArguments(index, query, options) {
+    return (0, _1.pushSearchOptions)(['FT.SEARCH', index, query], options);
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    const documents = [];
+    for (let i = 1; i < reply.length; i += 2) {
+        const tuples = reply[i + 1];
+        documents.push({
+            id: reply[i],
+            value: tuples.length === 2 && tuples[0] === '$' ?
+                JSON.parse(tuples[1]) :
+                (0, generic_transformers_1.transformTuplesReply)(tuples)
+        });
+    }
+    return {
+        total: reply[0],
+        documents
+    };
+}
+exports.transformReply = transformReply;

package/dist/commands/SPELLCHECK.d.ts

@@ -0,0 +1,24 @@
+interface SpellCheckTerms {
+    mode: 'INCLUDE' | 'EXCLUDE';
+    dictionary: string;
+}
+interface SpellCheckOptions {
+    DISTANCE?: number;
+    TERMS?: SpellCheckTerms | Array<SpellCheckTerms>;
+    DIALECT?: number;
+}
+export declare function transformArguments(index: string, query: string, options?: SpellCheckOptions): Array<string>;
+declare type SpellCheckRawReply = Array<[
+    _: string,
+    term: string,
+    suggestions: Array<[score: string, suggestion: string]>
+]>;
+declare type SpellCheckReply = Array<{
+    term: string;
+    suggestions: Array<{
+        score: number;
+        suggestion: string;
+    }>;
+}>;
+export declare function transformReply(rawReply: SpellCheckRawReply): SpellCheckReply;
+export {};

package/dist/commands/SPELLCHECK.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = void 0;
+function transformArguments(index, query, options) {
+    const args = ['FT.SPELLCHECK', index, query];
+    if (options?.DISTANCE) {
+        args.push('DISTANCE', options.DISTANCE.toString());
+    }
+    if (options?.TERMS) {
+        if (Array.isArray(options.TERMS)) {
+            for (const term of options.TERMS) {
+                pushTerms(args, term);
+            }
+        }
+        else {
+            pushTerms(args, options.TERMS);
+        }
+    }
+    if (options?.DIALECT) {
+        args.push('DIALECT', options.DIALECT.toString());
+    }
+    return args;
+}
+exports.transformArguments = transformArguments;
+function pushTerms(args, { mode, dictionary }) {
+    args.push('TERMS', mode, dictionary);
+}
+function transformReply(rawReply) {
+    return rawReply.map(([, term, suggestions]) => ({
+        term,
+        suggestions: suggestions.map(([score, suggestion]) => ({
+            score: Number(score),
+            suggestion
+        }))
+    }));
+}
+exports.transformReply = transformReply;

package/dist/commands/SUGADD.d.ts

@@ -0,0 +1,7 @@
+interface SugAddOptions {
+    INCR?: true;
+    PAYLOAD?: string;
+}
+export declare function transformArguments(key: string, string: string, score: number, options?: SugAddOptions): Array<string>;
+export declare function transformReply(): number;
+export {};

package/dist/commands/SUGADD.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = void 0;
+function transformArguments(key, string, score, options) {
+    const args = ['FT.SUGADD', key, string, score.toString()];
+    if (options?.INCR) {
+        args.push('INCR');
+    }
+    if (options?.PAYLOAD) {
+        args.push('PAYLOAD', options.PAYLOAD);
+    }
+    return args;
+}
+exports.transformArguments = transformArguments;

package/dist/commands/SUGDEL.d.ts

@@ -0,0 +1,2 @@
+export declare function transformArguments(key: string, string: string): Array<string>;
+export { transformBooleanReply as transformReply } from '@redis/client/dist/lib/commands/generic-transformers';

package/dist/commands/SUGDEL.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = void 0;
+function transformArguments(key, string) {
+    return ['FT.SUGDEL', key, string];
+}
+exports.transformArguments = transformArguments;
+var generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return generic_transformers_1.transformBooleanReply; } });

package/dist/commands/SUGGET.d.ts

@@ -0,0 +1,7 @@
+export declare const IS_READ_ONLY = true;
+export interface SugGetOptions {
+    FUZZY?: true;
+    MAX?: number;
+}
+export declare function transformArguments(key: string, prefix: string, options?: SugGetOptions): Array<string>;
+export declare function transformReply(): null | Array<string>;

package/dist/commands/SUGGET.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.IS_READ_ONLY = void 0;
+exports.IS_READ_ONLY = true;
+function transformArguments(key, prefix, options) {
+    const args = ['FT.SUGGET', key, prefix];
+    if (options?.FUZZY) {
+        args.push('FUZZY');
+    }
+    if (options?.MAX) {
+        args.push('MAX', options.MAX.toString());
+    }
+    return args;
+}
+exports.transformArguments = transformArguments;

package/dist/commands/SUGGET_WITHPAYLOADS.d.ts

@@ -0,0 +1,8 @@
+import { SugGetOptions } from './SUGGET';
+export { IS_READ_ONLY } from './SUGGET';
+export declare function transformArguments(key: string, prefix: string, options?: SugGetOptions): Array<string>;
+export interface SuggestionWithPayload {
+    suggestion: string;
+    payload: string | null;
+}
+export declare function transformReply(rawReply: Array<string | null> | null): Array<SuggestionWithPayload> | null;

package/dist/commands/SUGGET_WITHPAYLOADS.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const SUGGET_1 = require("./SUGGET");
+var SUGGET_2 = require("./SUGGET");
+Object.defineProperty(exports, "IS_READ_ONLY", { enumerable: true, get: function () { return SUGGET_2.IS_READ_ONLY; } });
+function transformArguments(key, prefix, options) {
+    return [
+        ...(0, SUGGET_1.transformArguments)(key, prefix, options),
+        'WITHPAYLOADS'
+    ];
+}
+exports.transformArguments = transformArguments;
+function transformReply(rawReply) {
+    if (rawReply === null)
+        return null;
+    const transformedReply = [];
+    for (let i = 0; i < rawReply.length; i += 2) {
+        transformedReply.push({
+            suggestion: rawReply[i],
+            payload: rawReply[i + 1]
+        });
+    }
+    return transformedReply;
+}
+exports.transformReply = transformReply;

package/dist/commands/SUGGET_WITHSCORES.d.ts

@@ -0,0 +1,8 @@
+import { SugGetOptions } from './SUGGET';
+export { IS_READ_ONLY } from './SUGGET';
+export declare function transformArguments(key: string, prefix: string, options?: SugGetOptions): Array<string>;
+export interface SuggestionWithScores {
+    suggestion: string;
+    score: number;
+}
+export declare function transformReply(rawReply: Array<string> | null): Array<SuggestionWithScores> | null;

package/dist/commands/SUGGET_WITHSCORES.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const SUGGET_1 = require("./SUGGET");
+var SUGGET_2 = require("./SUGGET");
+Object.defineProperty(exports, "IS_READ_ONLY", { enumerable: true, get: function () { return SUGGET_2.IS_READ_ONLY; } });
+function transformArguments(key, prefix, options) {
+    return [
+        ...(0, SUGGET_1.transformArguments)(key, prefix, options),
+        'WITHSCORES'
+    ];
+}
+exports.transformArguments = transformArguments;
+function transformReply(rawReply) {
+    if (rawReply === null)
+        return null;
+    const transformedReply = [];
+    for (let i = 0; i < rawReply.length; i += 2) {
+        transformedReply.push({
+            suggestion: rawReply[i],
+            score: Number(rawReply[i + 1])
+        });
+    }
+    return transformedReply;
+}
+exports.transformReply = transformReply;

package/dist/commands/SUGGET_WITHSCORES_WITHPAYLOADS.d.ts

@@ -0,0 +1,7 @@
+import { SugGetOptions } from './SUGGET';
+import { SuggestionWithPayload } from './SUGGET_WITHPAYLOADS';
+import { SuggestionWithScores } from './SUGGET_WITHSCORES';
+export { IS_READ_ONLY } from './SUGGET';
+export declare function transformArguments(key: string, prefix: string, options?: SugGetOptions): Array<string>;
+declare type SuggestionWithScoresAndPayloads = SuggestionWithScores & SuggestionWithPayload;
+export declare function transformReply(rawReply: Array<string | null> | null): Array<SuggestionWithScoresAndPayloads> | null;

package/dist/commands/SUGGET_WITHSCORES_WITHPAYLOADS.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const SUGGET_1 = require("./SUGGET");
+var SUGGET_2 = require("./SUGGET");
+Object.defineProperty(exports, "IS_READ_ONLY", { enumerable: true, get: function () { return SUGGET_2.IS_READ_ONLY; } });
+function transformArguments(key, prefix, options) {
+    return [
+        ...(0, SUGGET_1.transformArguments)(key, prefix, options),
+        'WITHSCORES',
+        'WITHPAYLOADS'
+    ];
+}
+exports.transformArguments = transformArguments;
+function transformReply(rawReply) {
+    if (rawReply === null)
+        return null;
+    const transformedReply = [];
+    for (let i = 0; i < rawReply.length; i += 3) {
+        transformedReply.push({
+            suggestion: rawReply[i],
+            score: Number(rawReply[i + 1]),
+            payload: rawReply[i + 2]
+        });
+    }
+    return transformedReply;
+}
+exports.transformReply = transformReply;

package/dist/commands/SUGLEN.d.ts

@@ -0,0 +1,3 @@
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(key: string): Array<string>;
+export declare function transformReply(): number;

package/dist/commands/SUGLEN.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.IS_READ_ONLY = void 0;
+exports.IS_READ_ONLY = true;
+function transformArguments(key) {
+    return ['FT.SUGLEN', key];
+}
+exports.transformArguments = transformArguments;

package/dist/commands/SYNDUMP.d.ts

@@ -0,0 +1,2 @@
+export declare function transformArguments(index: string): Array<string>;
+export declare function transformReply(): Array<string>;

package/dist/commands/SYNDUMP.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = void 0;
+function transformArguments(index) {
+    return ['FT.SYNDUMP', index];
+}
+exports.transformArguments = transformArguments;

package/dist/commands/SYNUPDATE.d.ts

@@ -0,0 +1,7 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+interface SynUpdateOptions {
+    SKIPINITIALSCAN?: true;
+}
+export declare function transformArguments(index: string, groupId: string, terms: string | Array<string>, options?: SynUpdateOptions): RedisCommandArguments;
+export declare function transformReply(): 'OK';
+export {};

package/dist/commands/SYNUPDATE.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+function transformArguments(index, groupId, terms, options) {
+    const args = ['FT.SYNUPDATE', index, groupId];
+    if (options?.SKIPINITIALSCAN) {
+        args.push('SKIPINITIALSCAN');
+    }
+    return (0, generic_transformers_1.pushVerdictArguments)(args, terms);
+}
+exports.transformArguments = transformArguments;

package/dist/commands/TAGVALS.d.ts

@@ -0,0 +1,2 @@
+export declare function transformArguments(index: string, fieldName: string): Array<string>;
+export declare function transformReply(): Array<string>;

package/dist/commands/TAGVALS.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = void 0;
+function transformArguments(index, fieldName) {
+    return ['FT.TAGVALS', index, fieldName];
+}
+exports.transformArguments = transformArguments;

package/dist/commands/_LIST.d.ts

@@ -0,0 +1,2 @@
+export declare function transformArguments(): Array<string>;
+export declare function transformReply(): Array<string>;

package/dist/commands/_LIST.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = void 0;
+function transformArguments() {
+    return ['FT._LIST'];
+}
+exports.transformArguments = transformArguments;