+1 -1

go.mod

reviewed

··· 88 88 github.com/pquerna/otp v1.4.0 89 89 github.com/prometheus/client_golang v1.18.0 90 90 github.com/quasoft/websspi v1.1.2 91 91 - github.com/redis/go-redis/v9 v9.5.2 91 91 + github.com/redis/go-redis/v9 v9.5.4 92 92 github.com/robfig/cron/v3 v3.0.1 93 93 github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 94 94 github.com/sassoftware/go-rpmutils v0.2.1-0.20240124161140-277b154961dd

+2 -2

go.sum

reviewed

··· 610 610 github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= 611 611 github.com/quasoft/websspi v1.1.2 h1:/mA4w0LxWlE3novvsoEL6BBA1WnjJATbjkh1kFrTidw= 612 612 github.com/quasoft/websspi v1.1.2/go.mod h1:HmVdl939dQ0WIXZhyik+ARdI03M6bQzaSEKcgpFmewk= 613 613 - github.com/redis/go-redis/v9 v9.5.2 h1:L0L3fcSNReTRGyZ6AqAEN0K56wYeYAwapBIhkvh0f3E= 614 614 - github.com/redis/go-redis/v9 v9.5.2/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= 613 613 + github.com/redis/go-redis/v9 v9.5.4 h1:vOFYDKKVgrI5u++QvnMT7DksSMYg7Aw/Np4vLJLKLwY= 614 614 + github.com/redis/go-redis/v9 v9.5.4/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= 615 615 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk= 616 616 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= 617 617 github.com/rhysd/actionlint v1.6.27 h1:xxwe8YmveBcC8lydW6GoHMGmB6H/MTqUU60F2p10wjw=

+668

modules/queue/mock/redisuniversalclient.go

reviewed

··· 2058 2058 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockUniversalClient)(nil).FCallRo), varargs...) 2059 2059 } 2060 2060 2061 2061 + // FTAggregate mocks base method. 2062 2062 + func (m *MockUniversalClient) FTAggregate(arg0 context.Context, arg1, arg2 string) *redis.MapStringInterfaceCmd { 2063 2063 + m.ctrl.T.Helper() 2064 2064 + ret := m.ctrl.Call(m, "FTAggregate", arg0, arg1, arg2) 2065 2065 + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) 2066 2066 + return ret0 2067 2067 + } 2068 2068 + 2069 2069 + // FTAggregate indicates an expected call of FTAggregate. 2070 2070 + func (mr *MockUniversalClientMockRecorder) FTAggregate(arg0, arg1, arg2 any) *gomock.Call { 2071 2071 + mr.mock.ctrl.T.Helper() 2072 2072 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregate", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregate), arg0, arg1, arg2) 2073 2073 + } 2074 2074 + 2075 2075 + // FTAggregateWithArgs mocks base method. 2076 2076 + func (m *MockUniversalClient) FTAggregateWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTAggregateOptions) *redis.AggregateCmd { 2077 2077 + m.ctrl.T.Helper() 2078 2078 + ret := m.ctrl.Call(m, "FTAggregateWithArgs", arg0, arg1, arg2, arg3) 2079 2079 + ret0, _ := ret[0].(*redis.AggregateCmd) 2080 2080 + return ret0 2081 2081 + } 2082 2082 + 2083 2083 + // FTAggregateWithArgs indicates an expected call of FTAggregateWithArgs. 2084 2084 + func (mr *MockUniversalClientMockRecorder) FTAggregateWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { 2085 2085 + mr.mock.ctrl.T.Helper() 2086 2086 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregateWithArgs), arg0, arg1, arg2, arg3) 2087 2087 + } 2088 2088 + 2089 2089 + // FTAliasAdd mocks base method. 2090 2090 + func (m *MockUniversalClient) FTAliasAdd(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { 2091 2091 + m.ctrl.T.Helper() 2092 2092 + ret := m.ctrl.Call(m, "FTAliasAdd", arg0, arg1, arg2) 2093 2093 + ret0, _ := ret[0].(*redis.StatusCmd) 2094 2094 + return ret0 2095 2095 + } 2096 2096 + 2097 2097 + // FTAliasAdd indicates an expected call of FTAliasAdd. 2098 2098 + func (mr *MockUniversalClientMockRecorder) FTAliasAdd(arg0, arg1, arg2 any) *gomock.Call { 2099 2099 + mr.mock.ctrl.T.Helper() 2100 2100 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasAdd), arg0, arg1, arg2) 2101 2101 + } 2102 2102 + 2103 2103 + // FTAliasDel mocks base method. 2104 2104 + func (m *MockUniversalClient) FTAliasDel(arg0 context.Context, arg1 string) *redis.StatusCmd { 2105 2105 + m.ctrl.T.Helper() 2106 2106 + ret := m.ctrl.Call(m, "FTAliasDel", arg0, arg1) 2107 2107 + ret0, _ := ret[0].(*redis.StatusCmd) 2108 2108 + return ret0 2109 2109 + } 2110 2110 + 2111 2111 + // FTAliasDel indicates an expected call of FTAliasDel. 2112 2112 + func (mr *MockUniversalClientMockRecorder) FTAliasDel(arg0, arg1 any) *gomock.Call { 2113 2113 + mr.mock.ctrl.T.Helper() 2114 2114 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasDel", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasDel), arg0, arg1) 2115 2115 + } 2116 2116 + 2117 2117 + // FTAliasUpdate mocks base method. 2118 2118 + func (m *MockUniversalClient) FTAliasUpdate(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { 2119 2119 + m.ctrl.T.Helper() 2120 2120 + ret := m.ctrl.Call(m, "FTAliasUpdate", arg0, arg1, arg2) 2121 2121 + ret0, _ := ret[0].(*redis.StatusCmd) 2122 2122 + return ret0 2123 2123 + } 2124 2124 + 2125 2125 + // FTAliasUpdate indicates an expected call of FTAliasUpdate. 2126 2126 + func (mr *MockUniversalClientMockRecorder) FTAliasUpdate(arg0, arg1, arg2 any) *gomock.Call { 2127 2127 + mr.mock.ctrl.T.Helper() 2128 2128 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasUpdate), arg0, arg1, arg2) 2129 2129 + } 2130 2130 + 2131 2131 + // FTAlter mocks base method. 2132 2132 + func (m *MockUniversalClient) FTAlter(arg0 context.Context, arg1 string, arg2 bool, arg3 []any) *redis.StatusCmd { 2133 2133 + m.ctrl.T.Helper() 2134 2134 + ret := m.ctrl.Call(m, "FTAlter", arg0, arg1, arg2, arg3) 2135 2135 + ret0, _ := ret[0].(*redis.StatusCmd) 2136 2136 + return ret0 2137 2137 + } 2138 2138 + 2139 2139 + // FTAlter indicates an expected call of FTAlter. 2140 2140 + func (mr *MockUniversalClientMockRecorder) FTAlter(arg0, arg1, arg2, arg3 any) *gomock.Call { 2141 2141 + mr.mock.ctrl.T.Helper() 2142 2142 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAlter", reflect.TypeOf((*MockUniversalClient)(nil).FTAlter), arg0, arg1, arg2, arg3) 2143 2143 + } 2144 2144 + 2145 2145 + // FTConfigGet mocks base method. 2146 2146 + func (m *MockUniversalClient) FTConfigGet(arg0 context.Context, arg1 string) *redis.MapMapStringInterfaceCmd { 2147 2147 + m.ctrl.T.Helper() 2148 2148 + ret := m.ctrl.Call(m, "FTConfigGet", arg0, arg1) 2149 2149 + ret0, _ := ret[0].(*redis.MapMapStringInterfaceCmd) 2150 2150 + return ret0 2151 2151 + } 2152 2152 + 2153 2153 + // FTConfigGet indicates an expected call of FTConfigGet. 2154 2154 + func (mr *MockUniversalClientMockRecorder) FTConfigGet(arg0, arg1 any) *gomock.Call { 2155 2155 + mr.mock.ctrl.T.Helper() 2156 2156 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigGet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigGet), arg0, arg1) 2157 2157 + } 2158 2158 + 2159 2159 + // FTConfigSet mocks base method. 2160 2160 + func (m *MockUniversalClient) FTConfigSet(arg0 context.Context, arg1 string, arg2 any) *redis.StatusCmd { 2161 2161 + m.ctrl.T.Helper() 2162 2162 + ret := m.ctrl.Call(m, "FTConfigSet", arg0, arg1, arg2) 2163 2163 + ret0, _ := ret[0].(*redis.StatusCmd) 2164 2164 + return ret0 2165 2165 + } 2166 2166 + 2167 2167 + // FTConfigSet indicates an expected call of FTConfigSet. 2168 2168 + func (mr *MockUniversalClientMockRecorder) FTConfigSet(arg0, arg1, arg2 any) *gomock.Call { 2169 2169 + mr.mock.ctrl.T.Helper() 2170 2170 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigSet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigSet), arg0, arg1, arg2) 2171 2171 + } 2172 2172 + 2173 2173 + // FTCreate mocks base method. 2174 2174 + func (m *MockUniversalClient) FTCreate(arg0 context.Context, arg1 string, arg2 *redis.FTCreateOptions, arg3 ...*redis.FieldSchema) *redis.StatusCmd { 2175 2175 + m.ctrl.T.Helper() 2176 2176 + varargs := []any{arg0, arg1, arg2} 2177 2177 + for _, a := range arg3 { 2178 2178 + varargs = append(varargs, a) 2179 2179 + } 2180 2180 + ret := m.ctrl.Call(m, "FTCreate", varargs...) 2181 2181 + ret0, _ := ret[0].(*redis.StatusCmd) 2182 2182 + return ret0 2183 2183 + } 2184 2184 + 2185 2185 + // FTCreate indicates an expected call of FTCreate. 2186 2186 + func (mr *MockUniversalClientMockRecorder) FTCreate(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { 2187 2187 + mr.mock.ctrl.T.Helper() 2188 2188 + varargs := append([]any{arg0, arg1, arg2}, arg3...) 2189 2189 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCreate", reflect.TypeOf((*MockUniversalClient)(nil).FTCreate), varargs...) 2190 2190 + } 2191 2191 + 2192 2192 + // FTCursorDel mocks base method. 2193 2193 + func (m *MockUniversalClient) FTCursorDel(arg0 context.Context, arg1 string, arg2 int) *redis.StatusCmd { 2194 2194 + m.ctrl.T.Helper() 2195 2195 + ret := m.ctrl.Call(m, "FTCursorDel", arg0, arg1, arg2) 2196 2196 + ret0, _ := ret[0].(*redis.StatusCmd) 2197 2197 + return ret0 2198 2198 + } 2199 2199 + 2200 2200 + // FTCursorDel indicates an expected call of FTCursorDel. 2201 2201 + func (mr *MockUniversalClientMockRecorder) FTCursorDel(arg0, arg1, arg2 any) *gomock.Call { 2202 2202 + mr.mock.ctrl.T.Helper() 2203 2203 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorDel", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorDel), arg0, arg1, arg2) 2204 2204 + } 2205 2205 + 2206 2206 + // FTCursorRead mocks base method. 2207 2207 + func (m *MockUniversalClient) FTCursorRead(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.MapStringInterfaceCmd { 2208 2208 + m.ctrl.T.Helper() 2209 2209 + ret := m.ctrl.Call(m, "FTCursorRead", arg0, arg1, arg2, arg3) 2210 2210 + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) 2211 2211 + return ret0 2212 2212 + } 2213 2213 + 2214 2214 + // FTCursorRead indicates an expected call of FTCursorRead. 2215 2215 + func (mr *MockUniversalClientMockRecorder) FTCursorRead(arg0, arg1, arg2, arg3 any) *gomock.Call { 2216 2216 + mr.mock.ctrl.T.Helper() 2217 2217 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorRead", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorRead), arg0, arg1, arg2, arg3) 2218 2218 + } 2219 2219 + 2220 2220 + // FTDictAdd mocks base method. 2221 2221 + func (m *MockUniversalClient) FTDictAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { 2222 2222 + m.ctrl.T.Helper() 2223 2223 + varargs := []any{arg0, arg1} 2224 2224 + for _, a := range arg2 { 2225 2225 + varargs = append(varargs, a) 2226 2226 + } 2227 2227 + ret := m.ctrl.Call(m, "FTDictAdd", varargs...) 2228 2228 + ret0, _ := ret[0].(*redis.IntCmd) 2229 2229 + return ret0 2230 2230 + } 2231 2231 + 2232 2232 + // FTDictAdd indicates an expected call of FTDictAdd. 2233 2233 + func (mr *MockUniversalClientMockRecorder) FTDictAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { 2234 2234 + mr.mock.ctrl.T.Helper() 2235 2235 + varargs := append([]any{arg0, arg1}, arg2...) 2236 2236 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTDictAdd), varargs...) 2237 2237 + } 2238 2238 + 2239 2239 + // FTDictDel mocks base method. 2240 2240 + func (m *MockUniversalClient) FTDictDel(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { 2241 2241 + m.ctrl.T.Helper() 2242 2242 + varargs := []any{arg0, arg1} 2243 2243 + for _, a := range arg2 { 2244 2244 + varargs = append(varargs, a) 2245 2245 + } 2246 2246 + ret := m.ctrl.Call(m, "FTDictDel", varargs...) 2247 2247 + ret0, _ := ret[0].(*redis.IntCmd) 2248 2248 + return ret0 2249 2249 + } 2250 2250 + 2251 2251 + // FTDictDel indicates an expected call of FTDictDel. 2252 2252 + func (mr *MockUniversalClientMockRecorder) FTDictDel(arg0, arg1 any, arg2 ...any) *gomock.Call { 2253 2253 + mr.mock.ctrl.T.Helper() 2254 2254 + varargs := append([]any{arg0, arg1}, arg2...) 2255 2255 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDel", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDel), varargs...) 2256 2256 + } 2257 2257 + 2258 2258 + // FTDictDump mocks base method. 2259 2259 + func (m *MockUniversalClient) FTDictDump(arg0 context.Context, arg1 string) *redis.StringSliceCmd { 2260 2260 + m.ctrl.T.Helper() 2261 2261 + ret := m.ctrl.Call(m, "FTDictDump", arg0, arg1) 2262 2262 + ret0, _ := ret[0].(*redis.StringSliceCmd) 2263 2263 + return ret0 2264 2264 + } 2265 2265 + 2266 2266 + // FTDictDump indicates an expected call of FTDictDump. 2267 2267 + func (mr *MockUniversalClientMockRecorder) FTDictDump(arg0, arg1 any) *gomock.Call { 2268 2268 + mr.mock.ctrl.T.Helper() 2269 2269 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDump", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDump), arg0, arg1) 2270 2270 + } 2271 2271 + 2272 2272 + // FTDropIndex mocks base method. 2273 2273 + func (m *MockUniversalClient) FTDropIndex(arg0 context.Context, arg1 string) *redis.StatusCmd { 2274 2274 + m.ctrl.T.Helper() 2275 2275 + ret := m.ctrl.Call(m, "FTDropIndex", arg0, arg1) 2276 2276 + ret0, _ := ret[0].(*redis.StatusCmd) 2277 2277 + return ret0 2278 2278 + } 2279 2279 + 2280 2280 + // FTDropIndex indicates an expected call of FTDropIndex. 2281 2281 + func (mr *MockUniversalClientMockRecorder) FTDropIndex(arg0, arg1 any) *gomock.Call { 2282 2282 + mr.mock.ctrl.T.Helper() 2283 2283 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndex", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndex), arg0, arg1) 2284 2284 + } 2285 2285 + 2286 2286 + // FTDropIndexWithArgs mocks base method. 2287 2287 + func (m *MockUniversalClient) FTDropIndexWithArgs(arg0 context.Context, arg1 string, arg2 *redis.FTDropIndexOptions) *redis.StatusCmd { 2288 2288 + m.ctrl.T.Helper() 2289 2289 + ret := m.ctrl.Call(m, "FTDropIndexWithArgs", arg0, arg1, arg2) 2290 2290 + ret0, _ := ret[0].(*redis.StatusCmd) 2291 2291 + return ret0 2292 2292 + } 2293 2293 + 2294 2294 + // FTDropIndexWithArgs indicates an expected call of FTDropIndexWithArgs. 2295 2295 + func (mr *MockUniversalClientMockRecorder) FTDropIndexWithArgs(arg0, arg1, arg2 any) *gomock.Call { 2296 2296 + mr.mock.ctrl.T.Helper() 2297 2297 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndexWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndexWithArgs), arg0, arg1, arg2) 2298 2298 + } 2299 2299 + 2300 2300 + // FTExplain mocks base method. 2301 2301 + func (m *MockUniversalClient) FTExplain(arg0 context.Context, arg1, arg2 string) *redis.StringCmd { 2302 2302 + m.ctrl.T.Helper() 2303 2303 + ret := m.ctrl.Call(m, "FTExplain", arg0, arg1, arg2) 2304 2304 + ret0, _ := ret[0].(*redis.StringCmd) 2305 2305 + return ret0 2306 2306 + } 2307 2307 + 2308 2308 + // FTExplain indicates an expected call of FTExplain. 2309 2309 + func (mr *MockUniversalClientMockRecorder) FTExplain(arg0, arg1, arg2 any) *gomock.Call { 2310 2310 + mr.mock.ctrl.T.Helper() 2311 2311 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplain", reflect.TypeOf((*MockUniversalClient)(nil).FTExplain), arg0, arg1, arg2) 2312 2312 + } 2313 2313 + 2314 2314 + // FTExplainWithArgs mocks base method. 2315 2315 + func (m *MockUniversalClient) FTExplainWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTExplainOptions) *redis.StringCmd { 2316 2316 + m.ctrl.T.Helper() 2317 2317 + ret := m.ctrl.Call(m, "FTExplainWithArgs", arg0, arg1, arg2, arg3) 2318 2318 + ret0, _ := ret[0].(*redis.StringCmd) 2319 2319 + return ret0 2320 2320 + } 2321 2321 + 2322 2322 + // FTExplainWithArgs indicates an expected call of FTExplainWithArgs. 2323 2323 + func (mr *MockUniversalClientMockRecorder) FTExplainWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { 2324 2324 + mr.mock.ctrl.T.Helper() 2325 2325 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplainWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTExplainWithArgs), arg0, arg1, arg2, arg3) 2326 2326 + } 2327 2327 + 2328 2328 + // FTInfo mocks base method. 2329 2329 + func (m *MockUniversalClient) FTInfo(arg0 context.Context, arg1 string) *redis.FTInfoCmd { 2330 2330 + m.ctrl.T.Helper() 2331 2331 + ret := m.ctrl.Call(m, "FTInfo", arg0, arg1) 2332 2332 + ret0, _ := ret[0].(*redis.FTInfoCmd) 2333 2333 + return ret0 2334 2334 + } 2335 2335 + 2336 2336 + // FTInfo indicates an expected call of FTInfo. 2337 2337 + func (mr *MockUniversalClientMockRecorder) FTInfo(arg0, arg1 any) *gomock.Call { 2338 2338 + mr.mock.ctrl.T.Helper() 2339 2339 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTInfo", reflect.TypeOf((*MockUniversalClient)(nil).FTInfo), arg0, arg1) 2340 2340 + } 2341 2341 + 2342 2342 + // FTSearch mocks base method. 2343 2343 + func (m *MockUniversalClient) FTSearch(arg0 context.Context, arg1, arg2 string) *redis.FTSearchCmd { 2344 2344 + m.ctrl.T.Helper() 2345 2345 + ret := m.ctrl.Call(m, "FTSearch", arg0, arg1, arg2) 2346 2346 + ret0, _ := ret[0].(*redis.FTSearchCmd) 2347 2347 + return ret0 2348 2348 + } 2349 2349 + 2350 2350 + // FTSearch indicates an expected call of FTSearch. 2351 2351 + func (mr *MockUniversalClientMockRecorder) FTSearch(arg0, arg1, arg2 any) *gomock.Call { 2352 2352 + mr.mock.ctrl.T.Helper() 2353 2353 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearch", reflect.TypeOf((*MockUniversalClient)(nil).FTSearch), arg0, arg1, arg2) 2354 2354 + } 2355 2355 + 2356 2356 + // FTSearchWithArgs mocks base method. 2357 2357 + func (m *MockUniversalClient) FTSearchWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTSearchOptions) *redis.FTSearchCmd { 2358 2358 + m.ctrl.T.Helper() 2359 2359 + ret := m.ctrl.Call(m, "FTSearchWithArgs", arg0, arg1, arg2, arg3) 2360 2360 + ret0, _ := ret[0].(*redis.FTSearchCmd) 2361 2361 + return ret0 2362 2362 + } 2363 2363 + 2364 2364 + // FTSearchWithArgs indicates an expected call of FTSearchWithArgs. 2365 2365 + func (mr *MockUniversalClientMockRecorder) FTSearchWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { 2366 2366 + mr.mock.ctrl.T.Helper() 2367 2367 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearchWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSearchWithArgs), arg0, arg1, arg2, arg3) 2368 2368 + } 2369 2369 + 2370 2370 + // FTSpellCheck mocks base method. 2371 2371 + func (m *MockUniversalClient) FTSpellCheck(arg0 context.Context, arg1, arg2 string) *redis.FTSpellCheckCmd { 2372 2372 + m.ctrl.T.Helper() 2373 2373 + ret := m.ctrl.Call(m, "FTSpellCheck", arg0, arg1, arg2) 2374 2374 + ret0, _ := ret[0].(*redis.FTSpellCheckCmd) 2375 2375 + return ret0 2376 2376 + } 2377 2377 + 2378 2378 + // FTSpellCheck indicates an expected call of FTSpellCheck. 2379 2379 + func (mr *MockUniversalClientMockRecorder) FTSpellCheck(arg0, arg1, arg2 any) *gomock.Call { 2380 2380 + mr.mock.ctrl.T.Helper() 2381 2381 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheck", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheck), arg0, arg1, arg2) 2382 2382 + } 2383 2383 + 2384 2384 + // FTSpellCheckWithArgs mocks base method. 2385 2385 + func (m *MockUniversalClient) FTSpellCheckWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd { 2386 2386 + m.ctrl.T.Helper() 2387 2387 + ret := m.ctrl.Call(m, "FTSpellCheckWithArgs", arg0, arg1, arg2, arg3) 2388 2388 + ret0, _ := ret[0].(*redis.FTSpellCheckCmd) 2389 2389 + return ret0 2390 2390 + } 2391 2391 + 2392 2392 + // FTSpellCheckWithArgs indicates an expected call of FTSpellCheckWithArgs. 2393 2393 + func (mr *MockUniversalClientMockRecorder) FTSpellCheckWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { 2394 2394 + mr.mock.ctrl.T.Helper() 2395 2395 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheckWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheckWithArgs), arg0, arg1, arg2, arg3) 2396 2396 + } 2397 2397 + 2398 2398 + // FTSynDump mocks base method. 2399 2399 + func (m *MockUniversalClient) FTSynDump(arg0 context.Context, arg1 string) *redis.FTSynDumpCmd { 2400 2400 + m.ctrl.T.Helper() 2401 2401 + ret := m.ctrl.Call(m, "FTSynDump", arg0, arg1) 2402 2402 + ret0, _ := ret[0].(*redis.FTSynDumpCmd) 2403 2403 + return ret0 2404 2404 + } 2405 2405 + 2406 2406 + // FTSynDump indicates an expected call of FTSynDump. 2407 2407 + func (mr *MockUniversalClientMockRecorder) FTSynDump(arg0, arg1 any) *gomock.Call { 2408 2408 + mr.mock.ctrl.T.Helper() 2409 2409 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynDump", reflect.TypeOf((*MockUniversalClient)(nil).FTSynDump), arg0, arg1) 2410 2410 + } 2411 2411 + 2412 2412 + // FTSynUpdate mocks base method. 2413 2413 + func (m *MockUniversalClient) FTSynUpdate(arg0 context.Context, arg1 string, arg2 any, arg3 []any) *redis.StatusCmd { 2414 2414 + m.ctrl.T.Helper() 2415 2415 + ret := m.ctrl.Call(m, "FTSynUpdate", arg0, arg1, arg2, arg3) 2416 2416 + ret0, _ := ret[0].(*redis.StatusCmd) 2417 2417 + return ret0 2418 2418 + } 2419 2419 + 2420 2420 + // FTSynUpdate indicates an expected call of FTSynUpdate. 2421 2421 + func (mr *MockUniversalClientMockRecorder) FTSynUpdate(arg0, arg1, arg2, arg3 any) *gomock.Call { 2422 2422 + mr.mock.ctrl.T.Helper() 2423 2423 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdate), arg0, arg1, arg2, arg3) 2424 2424 + } 2425 2425 + 2426 2426 + // FTSynUpdateWithArgs mocks base method. 2427 2427 + func (m *MockUniversalClient) FTSynUpdateWithArgs(arg0 context.Context, arg1 string, arg2 any, arg3 *redis.FTSynUpdateOptions, arg4 []any) *redis.StatusCmd { 2428 2428 + m.ctrl.T.Helper() 2429 2429 + ret := m.ctrl.Call(m, "FTSynUpdateWithArgs", arg0, arg1, arg2, arg3, arg4) 2430 2430 + ret0, _ := ret[0].(*redis.StatusCmd) 2431 2431 + return ret0 2432 2432 + } 2433 2433 + 2434 2434 + // FTSynUpdateWithArgs indicates an expected call of FTSynUpdateWithArgs. 2435 2435 + func (mr *MockUniversalClientMockRecorder) FTSynUpdateWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { 2436 2436 + mr.mock.ctrl.T.Helper() 2437 2437 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdateWithArgs), arg0, arg1, arg2, arg3, arg4) 2438 2438 + } 2439 2439 + 2440 2440 + // FTTagVals mocks base method. 2441 2441 + func (m *MockUniversalClient) FTTagVals(arg0 context.Context, arg1, arg2 string) *redis.StringSliceCmd { 2442 2442 + m.ctrl.T.Helper() 2443 2443 + ret := m.ctrl.Call(m, "FTTagVals", arg0, arg1, arg2) 2444 2444 + ret0, _ := ret[0].(*redis.StringSliceCmd) 2445 2445 + return ret0 2446 2446 + } 2447 2447 + 2448 2448 + // FTTagVals indicates an expected call of FTTagVals. 2449 2449 + func (mr *MockUniversalClientMockRecorder) FTTagVals(arg0, arg1, arg2 any) *gomock.Call { 2450 2450 + mr.mock.ctrl.T.Helper() 2451 2451 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTTagVals", reflect.TypeOf((*MockUniversalClient)(nil).FTTagVals), arg0, arg1, arg2) 2452 2452 + } 2453 2453 + 2454 2454 + // FT_List mocks base method. 2455 2455 + func (m *MockUniversalClient) FT_List(arg0 context.Context) *redis.StringSliceCmd { 2456 2456 + m.ctrl.T.Helper() 2457 2457 + ret := m.ctrl.Call(m, "FT_List", arg0) 2458 2458 + ret0, _ := ret[0].(*redis.StringSliceCmd) 2459 2459 + return ret0 2460 2460 + } 2461 2461 + 2462 2462 + // FT_List indicates an expected call of FT_List. 2463 2463 + func (mr *MockUniversalClientMockRecorder) FT_List(arg0 any) *gomock.Call { 2464 2464 + mr.mock.ctrl.T.Helper() 2465 2465 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FT_List", reflect.TypeOf((*MockUniversalClient)(nil).FT_List), arg0) 2466 2466 + } 2467 2467 + 2061 2468 // FlushAll mocks base method. 2062 2469 func (m *MockUniversalClient) FlushAll(arg0 context.Context) *redis.StatusCmd { 2063 2470 m.ctrl.T.Helper() ··· 2540 2947 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockUniversalClient)(nil).HExists), arg0, arg1, arg2) 2541 2948 } 2542 2949 2950 2950 + // HExpire mocks base method. 2951 2951 + func (m *MockUniversalClient) HExpire(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 ...string) *redis.IntSliceCmd { 2952 2952 + m.ctrl.T.Helper() 2953 2953 + varargs := []any{arg0, arg1, arg2} 2954 2954 + for _, a := range arg3 { 2955 2955 + varargs = append(varargs, a) 2956 2956 + } 2957 2957 + ret := m.ctrl.Call(m, "HExpire", varargs...) 2958 2958 + ret0, _ := ret[0].(*redis.IntSliceCmd) 2959 2959 + return ret0 2960 2960 + } 2961 2961 + 2962 2962 + // HExpire indicates an expected call of HExpire. 2963 2963 + func (mr *MockUniversalClientMockRecorder) HExpire(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { 2964 2964 + mr.mock.ctrl.T.Helper() 2965 2965 + varargs := append([]any{arg0, arg1, arg2}, arg3...) 2966 2966 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpire", reflect.TypeOf((*MockUniversalClient)(nil).HExpire), varargs...) 2967 2967 + } 2968 2968 + 2969 2969 + // HExpireAt mocks base method. 2970 2970 + func (m *MockUniversalClient) HExpireAt(arg0 context.Context, arg1 string, arg2 time.Time, arg3 ...string) *redis.IntSliceCmd { 2971 2971 + m.ctrl.T.Helper() 2972 2972 + varargs := []any{arg0, arg1, arg2} 2973 2973 + for _, a := range arg3 { 2974 2974 + varargs = append(varargs, a) 2975 2975 + } 2976 2976 + ret := m.ctrl.Call(m, "HExpireAt", varargs...) 2977 2977 + ret0, _ := ret[0].(*redis.IntSliceCmd) 2978 2978 + return ret0 2979 2979 + } 2980 2980 + 2981 2981 + // HExpireAt indicates an expected call of HExpireAt. 2982 2982 + func (mr *MockUniversalClientMockRecorder) HExpireAt(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { 2983 2983 + mr.mock.ctrl.T.Helper() 2984 2984 + varargs := append([]any{arg0, arg1, arg2}, arg3...) 2985 2985 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAt), varargs...) 2986 2986 + } 2987 2987 + 2988 2988 + // HExpireAtWithArgs mocks base method. 2989 2989 + func (m *MockUniversalClient) HExpireAtWithArgs(arg0 context.Context, arg1 string, arg2 time.Time, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd { 2990 2990 + m.ctrl.T.Helper() 2991 2991 + varargs := []any{arg0, arg1, arg2, arg3} 2992 2992 + for _, a := range arg4 { 2993 2993 + varargs = append(varargs, a) 2994 2994 + } 2995 2995 + ret := m.ctrl.Call(m, "HExpireAtWithArgs", varargs...) 2996 2996 + ret0, _ := ret[0].(*redis.IntSliceCmd) 2997 2997 + return ret0 2998 2998 + } 2999 2999 + 3000 3000 + // HExpireAtWithArgs indicates an expected call of HExpireAtWithArgs. 3001 3001 + func (mr *MockUniversalClientMockRecorder) HExpireAtWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { 3002 3002 + mr.mock.ctrl.T.Helper() 3003 3003 + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) 3004 3004 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAtWithArgs), varargs...) 3005 3005 + } 3006 3006 + 3007 3007 + // HExpireTime mocks base method. 3008 3008 + func (m *MockUniversalClient) HExpireTime(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd { 3009 3009 + m.ctrl.T.Helper() 3010 3010 + varargs := []any{arg0, arg1} 3011 3011 + for _, a := range arg2 { 3012 3012 + varargs = append(varargs, a) 3013 3013 + } 3014 3014 + ret := m.ctrl.Call(m, "HExpireTime", varargs...) 3015 3015 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3016 3016 + return ret0 3017 3017 + } 3018 3018 + 3019 3019 + // HExpireTime indicates an expected call of HExpireTime. 3020 3020 + func (mr *MockUniversalClientMockRecorder) HExpireTime(arg0, arg1 any, arg2 ...any) *gomock.Call { 3021 3021 + mr.mock.ctrl.T.Helper() 3022 3022 + varargs := append([]any{arg0, arg1}, arg2...) 3023 3023 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HExpireTime), varargs...) 3024 3024 + } 3025 3025 + 3026 3026 + // HExpireWithArgs mocks base method. 3027 3027 + func (m *MockUniversalClient) HExpireWithArgs(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd { 3028 3028 + m.ctrl.T.Helper() 3029 3029 + varargs := []any{arg0, arg1, arg2, arg3} 3030 3030 + for _, a := range arg4 { 3031 3031 + varargs = append(varargs, a) 3032 3032 + } 3033 3033 + ret := m.ctrl.Call(m, "HExpireWithArgs", varargs...) 3034 3034 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3035 3035 + return ret0 3036 3036 + } 3037 3037 + 3038 3038 + // HExpireWithArgs indicates an expected call of HExpireWithArgs. 3039 3039 + func (mr *MockUniversalClientMockRecorder) HExpireWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { 3040 3040 + mr.mock.ctrl.T.Helper() 3041 3041 + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) 3042 3042 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireWithArgs), varargs...) 3043 3043 + } 3044 3044 + 2543 3045 // HGet mocks base method. 2544 3046 func (m *MockUniversalClient) HGet(arg0 context.Context, arg1, arg2 string) *redis.StringCmd { 2545 3047 m.ctrl.T.Helper() ··· 2662 3164 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockUniversalClient)(nil).HMSet), varargs...) 2663 3165 } 2664 3166 3167 3167 + // HPExpire mocks base method. 3168 3168 + func (m *MockUniversalClient) HPExpire(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 ...string) *redis.IntSliceCmd { 3169 3169 + m.ctrl.T.Helper() 3170 3170 + varargs := []any{arg0, arg1, arg2} 3171 3171 + for _, a := range arg3 { 3172 3172 + varargs = append(varargs, a) 3173 3173 + } 3174 3174 + ret := m.ctrl.Call(m, "HPExpire", varargs...) 3175 3175 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3176 3176 + return ret0 3177 3177 + } 3178 3178 + 3179 3179 + // HPExpire indicates an expected call of HPExpire. 3180 3180 + func (mr *MockUniversalClientMockRecorder) HPExpire(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { 3181 3181 + mr.mock.ctrl.T.Helper() 3182 3182 + varargs := append([]any{arg0, arg1, arg2}, arg3...) 3183 3183 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpire", reflect.TypeOf((*MockUniversalClient)(nil).HPExpire), varargs...) 3184 3184 + } 3185 3185 + 3186 3186 + // HPExpireAt mocks base method. 3187 3187 + func (m *MockUniversalClient) HPExpireAt(arg0 context.Context, arg1 string, arg2 time.Time, arg3 ...string) *redis.IntSliceCmd { 3188 3188 + m.ctrl.T.Helper() 3189 3189 + varargs := []any{arg0, arg1, arg2} 3190 3190 + for _, a := range arg3 { 3191 3191 + varargs = append(varargs, a) 3192 3192 + } 3193 3193 + ret := m.ctrl.Call(m, "HPExpireAt", varargs...) 3194 3194 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3195 3195 + return ret0 3196 3196 + } 3197 3197 + 3198 3198 + // HPExpireAt indicates an expected call of HPExpireAt. 3199 3199 + func (mr *MockUniversalClientMockRecorder) HPExpireAt(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { 3200 3200 + mr.mock.ctrl.T.Helper() 3201 3201 + varargs := append([]any{arg0, arg1, arg2}, arg3...) 3202 3202 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAt), varargs...) 3203 3203 + } 3204 3204 + 3205 3205 + // HPExpireAtWithArgs mocks base method. 3206 3206 + func (m *MockUniversalClient) HPExpireAtWithArgs(arg0 context.Context, arg1 string, arg2 time.Time, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd { 3207 3207 + m.ctrl.T.Helper() 3208 3208 + varargs := []any{arg0, arg1, arg2, arg3} 3209 3209 + for _, a := range arg4 { 3210 3210 + varargs = append(varargs, a) 3211 3211 + } 3212 3212 + ret := m.ctrl.Call(m, "HPExpireAtWithArgs", varargs...) 3213 3213 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3214 3214 + return ret0 3215 3215 + } 3216 3216 + 3217 3217 + // HPExpireAtWithArgs indicates an expected call of HPExpireAtWithArgs. 3218 3218 + func (mr *MockUniversalClientMockRecorder) HPExpireAtWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { 3219 3219 + mr.mock.ctrl.T.Helper() 3220 3220 + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) 3221 3221 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAtWithArgs), varargs...) 3222 3222 + } 3223 3223 + 3224 3224 + // HPExpireTime mocks base method. 3225 3225 + func (m *MockUniversalClient) HPExpireTime(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd { 3226 3226 + m.ctrl.T.Helper() 3227 3227 + varargs := []any{arg0, arg1} 3228 3228 + for _, a := range arg2 { 3229 3229 + varargs = append(varargs, a) 3230 3230 + } 3231 3231 + ret := m.ctrl.Call(m, "HPExpireTime", varargs...) 3232 3232 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3233 3233 + return ret0 3234 3234 + } 3235 3235 + 3236 3236 + // HPExpireTime indicates an expected call of HPExpireTime. 3237 3237 + func (mr *MockUniversalClientMockRecorder) HPExpireTime(arg0, arg1 any, arg2 ...any) *gomock.Call { 3238 3238 + mr.mock.ctrl.T.Helper() 3239 3239 + varargs := append([]any{arg0, arg1}, arg2...) 3240 3240 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireTime), varargs...) 3241 3241 + } 3242 3242 + 3243 3243 + // HPExpireWithArgs mocks base method. 3244 3244 + func (m *MockUniversalClient) HPExpireWithArgs(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 redis.HExpireArgs, arg4 ...string) *redis.IntSliceCmd { 3245 3245 + m.ctrl.T.Helper() 3246 3246 + varargs := []any{arg0, arg1, arg2, arg3} 3247 3247 + for _, a := range arg4 { 3248 3248 + varargs = append(varargs, a) 3249 3249 + } 3250 3250 + ret := m.ctrl.Call(m, "HPExpireWithArgs", varargs...) 3251 3251 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3252 3252 + return ret0 3253 3253 + } 3254 3254 + 3255 3255 + // HPExpireWithArgs indicates an expected call of HPExpireWithArgs. 3256 3256 + func (mr *MockUniversalClientMockRecorder) HPExpireWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { 3257 3257 + mr.mock.ctrl.T.Helper() 3258 3258 + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) 3259 3259 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireWithArgs), varargs...) 3260 3260 + } 3261 3261 + 3262 3262 + // HPTTL mocks base method. 3263 3263 + func (m *MockUniversalClient) HPTTL(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd { 3264 3264 + m.ctrl.T.Helper() 3265 3265 + varargs := []any{arg0, arg1} 3266 3266 + for _, a := range arg2 { 3267 3267 + varargs = append(varargs, a) 3268 3268 + } 3269 3269 + ret := m.ctrl.Call(m, "HPTTL", varargs...) 3270 3270 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3271 3271 + return ret0 3272 3272 + } 3273 3273 + 3274 3274 + // HPTTL indicates an expected call of HPTTL. 3275 3275 + func (mr *MockUniversalClientMockRecorder) HPTTL(arg0, arg1 any, arg2 ...any) *gomock.Call { 3276 3276 + mr.mock.ctrl.T.Helper() 3277 3277 + varargs := append([]any{arg0, arg1}, arg2...) 3278 3278 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPTTL", reflect.TypeOf((*MockUniversalClient)(nil).HPTTL), varargs...) 3279 3279 + } 3280 3280 + 3281 3281 + // HPersist mocks base method. 3282 3282 + func (m *MockUniversalClient) HPersist(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd { 3283 3283 + m.ctrl.T.Helper() 3284 3284 + varargs := []any{arg0, arg1} 3285 3285 + for _, a := range arg2 { 3286 3286 + varargs = append(varargs, a) 3287 3287 + } 3288 3288 + ret := m.ctrl.Call(m, "HPersist", varargs...) 3289 3289 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3290 3290 + return ret0 3291 3291 + } 3292 3292 + 3293 3293 + // HPersist indicates an expected call of HPersist. 3294 3294 + func (mr *MockUniversalClientMockRecorder) HPersist(arg0, arg1 any, arg2 ...any) *gomock.Call { 3295 3295 + mr.mock.ctrl.T.Helper() 3296 3296 + varargs := append([]any{arg0, arg1}, arg2...) 3297 3297 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPersist", reflect.TypeOf((*MockUniversalClient)(nil).HPersist), varargs...) 3298 3298 + } 3299 3299 + 2665 3300 // HRandField mocks base method. 2666 3301 func (m *MockUniversalClient) HRandField(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { 2667 3302 m.ctrl.T.Helper() ··· 2704 3339 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockUniversalClient)(nil).HScan), arg0, arg1, arg2, arg3, arg4) 2705 3340 } 2706 3341 3342 3342 + // HScanNoValues mocks base method. 3343 3343 + func (m *MockUniversalClient) HScanNoValues(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd { 3344 3344 + m.ctrl.T.Helper() 3345 3345 + ret := m.ctrl.Call(m, "HScanNoValues", arg0, arg1, arg2, arg3, arg4) 3346 3346 + ret0, _ := ret[0].(*redis.ScanCmd) 3347 3347 + return ret0 3348 3348 + } 3349 3349 + 3350 3350 + // HScanNoValues indicates an expected call of HScanNoValues. 3351 3351 + func (mr *MockUniversalClientMockRecorder) HScanNoValues(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { 3352 3352 + mr.mock.ctrl.T.Helper() 3353 3353 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScanNoValues", reflect.TypeOf((*MockUniversalClient)(nil).HScanNoValues), arg0, arg1, arg2, arg3, arg4) 3354 3354 + } 3355 3355 + 2707 3356 // HSet mocks base method. 2708 3357 func (m *MockUniversalClient) HSet(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { 2709 3358 m.ctrl.T.Helper() ··· 2735 3384 func (mr *MockUniversalClientMockRecorder) HSetNX(arg0, arg1, arg2, arg3 any) *gomock.Call { 2736 3385 mr.mock.ctrl.T.Helper() 2737 3386 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockUniversalClient)(nil).HSetNX), arg0, arg1, arg2, arg3) 3387 3387 + } 3388 3388 + 3389 3389 + // HTTL mocks base method. 3390 3390 + func (m *MockUniversalClient) HTTL(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntSliceCmd { 3391 3391 + m.ctrl.T.Helper() 3392 3392 + varargs := []any{arg0, arg1} 3393 3393 + for _, a := range arg2 { 3394 3394 + varargs = append(varargs, a) 3395 3395 + } 3396 3396 + ret := m.ctrl.Call(m, "HTTL", varargs...) 3397 3397 + ret0, _ := ret[0].(*redis.IntSliceCmd) 3398 3398 + return ret0 3399 3399 + } 3400 3400 + 3401 3401 + // HTTL indicates an expected call of HTTL. 3402 3402 + func (mr *MockUniversalClientMockRecorder) HTTL(arg0, arg1 any, arg2 ...any) *gomock.Call { 3403 3403 + mr.mock.ctrl.T.Helper() 3404 3404 + varargs := append([]any{arg0, arg1}, arg2...) 3405 3405 + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTL", reflect.TypeOf((*MockUniversalClient)(nil).HTTL), varargs...) 2738 3406 } 2739 3407 2740 3408 // HVals mocks base method.