@ominity/api-typescript 1.0.0 → 1.1.0

package/src/funcs/settings/index.ts

@@ -8,3 +8,9 @@ export * from "./paymentMethodsGet.js";
 export * from "./paymentMethodsList.js";
 export * from "./socialProvidersGet.js";
 export * from "./socialProvidersList.js";
+export * from "./socialProvidersCreateLink.js";
+export * from "./socialProviderUsersExchangeAccessCode.js";
+export * from "./socialProviderUsersList.js";
+export * from "./socialProviderUsersGet.js";
+export * from "./socialProviderUsersUpdate.js";
+export * from "./socialProviderUsersDelete.js";

package/src/funcs/settings/socialProviderUsersDelete.ts

@@ -0,0 +1,108 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as M from "../../lib/matchers.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import { pathToFunc } from "../../lib/url.js";
+import * as operations from "../../models/operations/index.js";
+import { OminityError } from "../../models/errors/ominity-error.js";
+import {
+    ConnectionError,
+    InvalidRequestError,
+    RequestAbortedError,
+    RequestTimeoutError,
+    UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import { Result } from "../../types/fp.js";
+
+/**
+ * Delete social provider user.
+ */
+export async function socialProviderUsersDelete(
+    client: ClientSDK,
+    request: operations.DeleteSocialProviderUserRequest,
+    options?: RequestOptions,
+): Promise<
+    Result<
+        operations.DeleteSocialProviderUserResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >
+> {
+    const input: operations.DeleteSocialProviderUserRequest = request;
+
+    const securitySettings = client._options.security;
+    const securityInput = await extractSecurity(securitySettings);
+    const security = resolveGlobalSecurity(securityInput);
+
+    const context = {
+        operationID: "deleteSocialProviderUser",
+        oAuth2Scopes: [],
+        securitySource: client._options.security,
+        baseURL: client._baseURL,
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        resolvedSecurity: security,
+        options: options,
+    };
+
+    const requestRes = client._createRequest(
+        context,
+        {
+            security: security,
+            method: "DELETE",
+            path: pathToFunc("/settings/socialproviders/{providerId}/users/{id}")(input),
+            headers: new Headers(options?.headers),
+            query: "",
+            body: null,
+            timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+        },
+        options,
+    );
+    if (!requestRes.ok) {
+        return requestRes;
+    }
+    const req = requestRes.value;
+
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    });
+    if (!doResult.ok) {
+        return doResult;
+    }
+    const response = doResult.value;
+
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+
+    const [result] = await M.match<
+        operations.DeleteSocialProviderUserResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >(
+        M.nil(
+            204,
+            operations.DeleteSocialProviderUserResponse$inboundSchema,
+        ),
+        M.fail(
+            ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        ),
+    )(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return result;
+    }
+
+    return result;
+}

package/src/funcs/settings/socialProviderUsersExchangeAccessCode.ts

@@ -0,0 +1,112 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { encodeSimpleQuery } from "../../lib/encodings.js";
+import * as M from "../../lib/matchers.js";
+import { pathToFunc } from "../../lib/url.js";
+import * as operations from "../../models/operations/index.js";
+import { OminityError } from "../../models/errors/ominity-error.js";
+import {
+    ConnectionError,
+    InvalidRequestError,
+    RequestAbortedError,
+    RequestTimeoutError,
+    UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import { Result } from "../../types/fp.js";
+
+/**
+ * Exchange social provider access code.
+ */
+export async function socialProviderUsersExchangeAccessCode(
+    client: ClientSDK,
+    request: operations.ExchangeSocialProviderAccessCodeRequest,
+    options?: RequestOptions,
+): Promise<
+    Result<
+        operations.ExchangeSocialProviderAccessCodeResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >
+> {
+    const input: operations.ExchangeSocialProviderAccessCodeRequest = request;
+
+    const security = null;
+
+    const simpleQuery = encodeSimpleQuery({
+        "code": input.code,
+    });
+
+    const finalQuery = new URLSearchParams(simpleQuery || "");
+
+    const context = {
+        operationID: "exchangeProviderAccessCode",
+        oAuth2Scopes: [],
+        securitySource: client._options.security,
+        baseURL: client._baseURL,
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        resolvedSecurity: security,
+        options: options,
+    };
+
+    const requestRes = client._createRequest(
+        context,
+        {
+            security: security,
+            method: "GET",
+            path: pathToFunc("/settings/socialproviders/{providerId}/users/token")(input),
+            headers: new Headers(options?.headers),
+            query: finalQuery.toString(),
+            body: null,
+            timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+        },
+        options,
+    );
+    if (!requestRes.ok) {
+        return requestRes;
+    }
+    const req = requestRes.value;
+
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    });
+    if (!doResult.ok) {
+        return doResult;
+    }
+    const response = doResult.value;
+
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+
+    const [result] = await M.match<
+        operations.ExchangeSocialProviderAccessCodeResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >(
+        M.json(
+            200,
+            operations.ExchangeSocialProviderAccessCodeResponse$inboundSchema,
+        ),
+        M.fail(
+            ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        ),
+    )(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return result;
+    }
+
+    return result;
+}

package/src/funcs/settings/socialProviderUsersGet.ts

@@ -0,0 +1,108 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as M from "../../lib/matchers.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import { pathToFunc } from "../../lib/url.js";
+import * as operations from "../../models/operations/index.js";
+import { OminityError } from "../../models/errors/ominity-error.js";
+import {
+    ConnectionError,
+    InvalidRequestError,
+    RequestAbortedError,
+    RequestTimeoutError,
+    UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import { Result } from "../../types/fp.js";
+
+/**
+ * Get social provider user.
+ */
+export async function socialProviderUsersGet(
+    client: ClientSDK,
+    request: operations.GetSocialProviderUserRequest,
+    options?: RequestOptions,
+): Promise<
+    Result<
+        operations.GetSocialProviderUserResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >
+> {
+    const input: operations.GetSocialProviderUserRequest = request;
+
+    const securitySettings = client._options.security;
+    const securityInput = await extractSecurity(securitySettings);
+    const security = resolveGlobalSecurity(securityInput);
+
+    const context = {
+        operationID: "getSocialProviderUser",
+        oAuth2Scopes: [],
+        securitySource: client._options.security,
+        baseURL: client._baseURL,
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        resolvedSecurity: security,
+        options: options,
+    };
+
+    const requestRes = client._createRequest(
+        context,
+        {
+            security: security,
+            method: "GET",
+            path: pathToFunc("/settings/socialproviders/{providerId}/users/{id}")(input),
+            headers: new Headers(options?.headers),
+            query: "",
+            body: null,
+            timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+        },
+        options,
+    );
+    if (!requestRes.ok) {
+        return requestRes;
+    }
+    const req = requestRes.value;
+
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    });
+    if (!doResult.ok) {
+        return doResult;
+    }
+    const response = doResult.value;
+
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+
+    const [result] = await M.match<
+        operations.GetSocialProviderUserResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >(
+        M.json(
+            200,
+            operations.GetSocialProviderUserResponse$inboundSchema,
+        ),
+        M.fail(
+            ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        ),
+    )(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return result;
+    }
+
+    return result;
+}

package/src/funcs/settings/socialProviderUsersList.ts

@@ -0,0 +1,124 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { encodeSimpleQuery } from "../../lib/encodings.js";
+import * as M from "../../lib/matchers.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import { pathToFunc } from "../../lib/url.js";
+import * as operations from "../../models/operations/index.js";
+import { OminityError } from "../../models/errors/ominity-error.js";
+import {
+    ConnectionError,
+    InvalidRequestError,
+    RequestAbortedError,
+    RequestTimeoutError,
+    UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import { Result } from "../../types/fp.js";
+
+/**
+ * List social provider users.
+ */
+export async function socialProviderUsersList(
+    client: ClientSDK,
+    request: operations.ListSocialProviderUsersRequest,
+    options?: RequestOptions,
+): Promise<
+    Result<
+        operations.ListSocialProviderUsersResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >
+> {
+    const input: operations.ListSocialProviderUsersRequest = request;
+
+    const securitySettings = client._options.security;
+    const securityInput = await extractSecurity(securitySettings);
+    const security = resolveGlobalSecurity(securityInput);
+
+    const simpleQuery = encodeSimpleQuery({
+        "page": input.page,
+        "limit": input.limit,
+        "sort": input.sort,
+        "filter[id]": input.filter?.id,
+        "filter[user]": input.filter?.user,
+        "filter[identifier]": input.filter?.identifier,
+        "filter[name]": input.filter?.name,
+        "filter[email]": input.filter?.email,
+    });
+
+    const finalQuery = new URLSearchParams(simpleQuery || "");
+
+    const context = {
+        operationID: "listSocialProviderUsers",
+        oAuth2Scopes: [],
+        securitySource: client._options.security,
+        baseURL: client._baseURL,
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        resolvedSecurity: security,
+        options: options,
+    };
+
+    const requestRes = client._createRequest(
+        context,
+        {
+            security: security,
+            method: "GET",
+            path: pathToFunc("/settings/socialproviders/{providerId}/users")({
+                providerId: input.providerId,
+            }),
+            headers: new Headers(options?.headers),
+            query: finalQuery.toString(),
+            body: null,
+            timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+        },
+        options,
+    );
+    if (!requestRes.ok) {
+        return requestRes;
+    }
+    const req = requestRes.value;
+
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    });
+    if (!doResult.ok) {
+        return doResult;
+    }
+    const response = doResult.value;
+
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+
+    const [result] = await M.match<
+        operations.ListSocialProviderUsersResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >(
+        M.json(
+            200,
+            operations.ListSocialProviderUsersResponse$inboundSchema,
+        ),
+        M.fail(
+            ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        ),
+    )(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return result;
+    }
+
+    return result;
+}

package/src/funcs/settings/socialProviderUsersUpdate.ts

@@ -0,0 +1,115 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as M from "../../lib/matchers.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import { pathToFunc } from "../../lib/url.js";
+import * as operations from "../../models/operations/index.js";
+import { OminityError } from "../../models/errors/ominity-error.js";
+import {
+    ConnectionError,
+    InvalidRequestError,
+    RequestAbortedError,
+    RequestTimeoutError,
+    UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import { Result } from "../../types/fp.js";
+
+/**
+ * Update social provider user.
+ */
+export async function socialProviderUsersUpdate(
+    client: ClientSDK,
+    request: operations.UpdateSocialProviderUserRequest,
+    options?: RequestOptions,
+): Promise<
+    Result<
+        operations.UpdateSocialProviderUserResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >
+> {
+    const input: operations.UpdateSocialProviderUserRequest = request;
+    const headers = new Headers(options?.headers);
+    headers.set("Content-Type", "application/json");
+
+    const securitySettings = client._options.security;
+    const securityInput = await extractSecurity(securitySettings);
+    const security = resolveGlobalSecurity(securityInput);
+
+    const context = {
+        operationID: "updateSocialProviderUser",
+        oAuth2Scopes: [],
+        securitySource: client._options.security,
+        baseURL: client._baseURL,
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        resolvedSecurity: security,
+        options: options,
+    };
+
+    const requestRes = client._createRequest(
+        context,
+        {
+            security: security,
+            method: "PATCH",
+            path: pathToFunc("/settings/socialproviders/{providerId}/users/{id}")({
+                providerId: input.providerId,
+                id: input.id,
+            }),
+            headers,
+            query: "",
+            body: JSON.stringify({
+                userId: input.userId,
+            }),
+            timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+        },
+        options,
+    );
+    if (!requestRes.ok) {
+        return requestRes;
+    }
+    const req = requestRes.value;
+
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    });
+    if (!doResult.ok) {
+        return doResult;
+    }
+    const response = doResult.value;
+
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+
+    const [result] = await M.match<
+        operations.UpdateSocialProviderUserResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >(
+        M.json(
+            200,
+            operations.UpdateSocialProviderUserResponse$inboundSchema,
+        ),
+        M.fail(
+            ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        ),
+    )(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return result;
+    }
+
+    return result;
+}

package/src/funcs/settings/socialProvidersCreateLink.ts

@@ -0,0 +1,115 @@
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { encodeSimpleQuery } from "../../lib/encodings.js";
+import * as M from "../../lib/matchers.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import { pathToFunc } from "../../lib/url.js";
+import * as operations from "../../models/operations/index.js";
+import { OminityError } from "../../models/errors/ominity-error.js";
+import {
+    ConnectionError,
+    InvalidRequestError,
+    RequestAbortedError,
+    RequestTimeoutError,
+    UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import { Result } from "../../types/fp.js";
+
+/**
+ * Create social provider redirect link.
+ */
+export async function socialProvidersCreateLink(
+    client: ClientSDK,
+    request: operations.CreateSocialProviderLinkRequest,
+    options?: RequestOptions,
+): Promise<
+    Result<
+        operations.CreateSocialProviderLinkResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >
+> {
+    const input: operations.CreateSocialProviderLinkRequest = request;
+
+    const securitySettings = client._options.security;
+    const securityInput = await extractSecurity(securitySettings);
+    const security = resolveGlobalSecurity(securityInput);
+
+    const simpleQuery = encodeSimpleQuery({
+        "redirectUrl": input.redirectUrl,
+    });
+
+    const finalQuery = new URLSearchParams(simpleQuery || "");
+
+    const context = {
+        operationID: "createSocialProviderRedirectLink",
+        oAuth2Scopes: [],
+        securitySource: client._options.security,
+        baseURL: client._baseURL,
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        resolvedSecurity: security,
+        options: options,
+    };
+
+    const requestRes = client._createRequest(
+        context,
+        {
+            security: security,
+            method: "GET",
+            path: pathToFunc("/settings/socialproviders/{id}/link")(input),
+            headers: new Headers(options?.headers),
+            query: finalQuery.toString(),
+            body: null,
+            timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+        },
+        options,
+    );
+    if (!requestRes.ok) {
+        return requestRes;
+    }
+    const req = requestRes.value;
+
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    });
+    if (!doResult.ok) {
+        return doResult;
+    }
+    const response = doResult.value;
+
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+
+    const [result] = await M.match<
+        operations.CreateSocialProviderLinkResponse,
+        | OminityError
+        | SDKValidationError
+        | UnexpectedClientError
+        | InvalidRequestError
+        | RequestAbortedError
+        | RequestTimeoutError
+        | ConnectionError
+    >(
+        M.json(
+            200,
+            operations.CreateSocialProviderLinkResponse$inboundSchema,
+        ),
+        M.fail(
+            ["400", "401", "403", "404", "422", "4XX", "500", "5XX"],
+        ),
+    )(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return result;
+    }
+
+    return result;
+}