@dfns/sdk 0.0.0-prealpha.9

package/codegen/datamodel/Assets/types.d.ts

@@ -0,0 +1,225 @@
+import { Amount, AssetSymbol, DfnsCertificate, EntityId, Initiator, IntegerPositiveStrict, IsoDatetime, PublicKey, Tag } from '../Foundations';
+export type PaymentInitiation = {
+    id: EntityId;
+    paymentId: EntityId;
+    externalId?: EntityId;
+    status: PaymentInitiationStatus;
+    orgId?: EntityId;
+    initiator: Initiator;
+    assetSymbol: AssetSymbol;
+    amount: Amount;
+    sender: DfnsAssetAccount;
+    receiver: PaymentInstrument;
+    dateInitiated: IsoDatetime;
+    /**
+     * In case payment initiation is rejected by the system, this field will contain information about it.
+     *
+     */
+    rejectionReason?: string;
+};
+export type BlockchainWalletAddress = {
+    kind: PaymentInstrumentKind.BlockchainWalletAddress;
+    address: string;
+};
+export type DfnsAssetAccount = {
+    kind: PaymentInstrumentKind.DfnsAssetAccount;
+    id: EntityId;
+};
+export type AssetAccount = {
+    /**
+     * Multiple tags can be attached to an entity to categorise or otherwise mark it. For example tags could indicate risk (High, Medium, Low), departments (Trading, Sales, IT), purpose (Treasury, Hot, Deposits), and jurisdictions (US, EU, DE).
+     *
+     * Multiple tags can be attached to same entity.
+     */
+    tags?: Tag[];
+    /**
+     * Field can be used if entity is created in external (customer’s) system first. This way the external id can be attached to identify entity from Dfns’s data store.
+     */
+    externalId?: string;
+    /**
+     * Indicates id of the Organisation, such as usually a customer, or sub-devision, sub-tenant, and others.
+     */
+    orgId: EntityId;
+    id: EntityId;
+    /**
+     * Indicates whether account is ready to be used.
+     */
+    status: AssetAccountStatus;
+    /**
+     * Blockchain address for a chosen Blockchain network.
+     */
+    address?: string;
+    /**
+     * `PublicKey` which is used by `AssetAccount`. Usually this is used to derive addresses on a given blockchain network.
+     *
+     * Alternatively can be used to verify signatures produced by the platform.
+     */
+    publicKey?: string;
+    publicKeyId?: EntityId;
+    /**
+     * # [ENUM]
+     *
+     * Asset symbol indicating which asset this account is managing. BTC or ETH are obvious examples, but there are thousands of possible symbols. In case of coins (ERC20 and alike) use `COIN.BLOCKCHAIN` syntax, such as USDC.ETH or USDC.SOL to indicate that USDC on Ethereum or USDC on Solana is required. To get a list of all allowed values, send a `CreateAssetAccount` request with the `assetSymbol` field empty.
+     */
+    assetSymbol: AssetSymbol;
+    /**
+     * Custom name that can be added for an account.
+     */
+    name: string;
+    dateCreated: IsoDatetime;
+    dateUpdate: IsoDatetime;
+    authorizations?: AssetAccountAuthorization[];
+};
+export type Payment = {
+    /**
+     * Multiple tags can be attached to an entity to categorise or otherwise mark it. For example tags could indicate risk (High, Medium, Low), departments (Trading, Sales, IT), purpose (Treasury, Hot, Deposits), and jurisdictions (US, EU, DE).
+     *
+     * Multiple tags can be attached to same entity.
+     */
+    tags?: Tag[];
+    /**
+     * Field can be used if entity is created in external (customer’s) system first. This way the external id can be attached to identify entity from Dfns’s data store.
+     */
+    externalId?: string;
+    /**
+     * Indicates id of the Organisation, such as usually a customer, or sub-devision, sub-tenant, and others.
+     */
+    orgId: EntityId;
+    id: EntityId;
+    status: PaymentStatus;
+    initiator: Initiator;
+    assetAccountId: EntityId;
+    assetSymbol: AssetSymbol;
+    amount: Amount;
+    sender: PaymentInstrument;
+    receiver: PaymentInstrument;
+    /**
+     * SWIFT (MT, ISO15022) field. Represents additional information about payment.
+     *
+     */
+    narrative?: string;
+    note?: string;
+    receiverAddress: string;
+    policyCertificate?: DfnsCertificate;
+    dateCreated: IsoDatetime;
+    dateUpdated: IsoDatetime;
+    dateExecuted?: IsoDatetime;
+    dateBroadcasted?: IsoDatetime;
+    dateFirstConfirmed?: IsoDatetime;
+    dateConfirmed?: IsoDatetime;
+    dateSettled?: IsoDatetime;
+    txHash?: string;
+    blockHeight?: number;
+    direction: PaymentDirection;
+    fee?: Amount;
+};
+export type AssetAccountAuthorization = {
+    kind: AssetAccountAuthorizationKind;
+    entityId: EntityId;
+    permission: AssetAccountPermissions;
+};
+/**
+ * Balance of one asset account.
+ */
+export type AssetAccountBalance = {
+    /**
+     * Id of the AssetAccount.
+     */
+    id: EntityId;
+    /**
+     * Asset Symbol of the account.
+     */
+    assetSymbol: AssetSymbol;
+    /**
+     * Balance of the account.
+     */
+    balance: Amount;
+    maxUnitBalance: Amount;
+};
+export type UpdateAssetAccountPayload = {
+    /**
+     * Indicates whether account is ready to be used.
+     */
+    status: AssetAccountStatus;
+    /**
+     * Blockchain address for a chosen Blockchain network.
+     */
+    address?: string;
+    /**
+     * `PublicKey` which is used by `AssetAccount`. Usually this is used to derive addresses on a given blockchain network.
+     *
+     * Alternatively can be used to verify signatures produced by the platform.
+     */
+    publicKey?: string;
+    /**
+     * Custom name that can be added for an account.
+     */
+    name?: string;
+};
+export type CreateAssetAccountInput = {
+    /**
+     * # [ENUM]
+     *
+     * Asset symbol indicating which asset this account is managing. BTC or ETH are obvious examples, but there are thousands of possible symbols. In case of coins (ERC20 and alike) use `COIN.BLOCKCHAIN` syntax, such as USDC.ETH or USDC.SOL to indicate that USDC on Ethereum or USDC on Solana is required. To get a list of all allowed values, send a `CreateAssetAccount` request with the `assetSymbol` field empty.
+     */
+    assetSymbol: AssetSymbol;
+    groupSize?: IntegerPositiveStrict;
+    groupThreshold?: IntegerPositiveStrict;
+    /**
+     * `PublicKey` which is used by `AssetAccount`. Usually this is used to derive addresses on a given blockchain network.
+     *
+     * Alternatively can be used to verify signatures produced by the platform.
+     */
+    publicKey?: PublicKey;
+    externalId?: string;
+    tags?: Tag[];
+    /**
+     * Custom name that can be added for an account.
+     */
+    name?: string;
+};
+export type CreatePaymentInput = {
+    externalId?: string;
+    assetSymbol: AssetSymbol;
+    amount: Amount;
+    receiver: PaymentInstrument;
+    note?: string;
+    narrative?: string;
+};
+export type PaymentInstrument = BlockchainWalletAddress | DfnsAssetAccount;
+export declare enum PaymentInstrumentKind {
+    DfnsAssetAccount = "DfnsAssetAccount",
+    BlockchainWalletAddress = "BlockchainWalletAddress"
+}
+export declare enum PaymentInitiationStatus {
+    Initiated = "Initiated",
+    Canceled = "Canceled",
+    Rejected = "Rejected"
+}
+export declare enum AssetAccountStatus {
+    Creating = "Creating",
+    Enabled = "Enabled",
+    Failed = "Failed"
+}
+export declare enum PaymentStatus {
+    Initiated = "Initiated",
+    Rejected = "Rejected",
+    Approved = "Approved",
+    Executed = "Executed",
+    Failed = "Failed",
+    Confirmed = "Confirmed"
+}
+export declare enum AssetAccountAuthorizationKind {
+    Employee = "Employee",
+    Group = "Group",
+    ApiKey = "ApiKey"
+}
+export declare enum AssetAccountPermissions {
+    InitiatePayments = "InitiatePayments",
+    ReadBalance = "ReadBalance",
+    ReadPublicKey = "ReadPublicKey"
+}
+export declare enum PaymentDirection {
+    Incoming = "Incoming",
+    Outgoing = "Outgoing"
+}

package/codegen/datamodel/Assets/types.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentDirection = exports.AssetAccountPermissions = exports.AssetAccountAuthorizationKind = exports.PaymentStatus = exports.AssetAccountStatus = exports.PaymentInitiationStatus = exports.PaymentInstrumentKind = void 0;
+// FIXME: Missing documentation for PaymentInstrumentKind
+var PaymentInstrumentKind;
+(function (PaymentInstrumentKind) {
+    // FIXME: Missing documentation for DfnsAssetAccount
+    PaymentInstrumentKind["DfnsAssetAccount"] = "DfnsAssetAccount";
+    // FIXME: Missing documentation for BlockchainWalletAddress
+    PaymentInstrumentKind["BlockchainWalletAddress"] = "BlockchainWalletAddress";
+})(PaymentInstrumentKind = exports.PaymentInstrumentKind || (exports.PaymentInstrumentKind = {}));
+// FIXME: Missing documentation for PaymentInitiationStatus
+var PaymentInitiationStatus;
+(function (PaymentInitiationStatus) {
+    // FIXME: Missing documentation for Initiated
+    PaymentInitiationStatus["Initiated"] = "Initiated";
+    // FIXME: Missing documentation for Canceled
+    PaymentInitiationStatus["Canceled"] = "Canceled";
+    // FIXME: Missing documentation for Rejected
+    PaymentInitiationStatus["Rejected"] = "Rejected";
+})(PaymentInitiationStatus = exports.PaymentInitiationStatus || (exports.PaymentInitiationStatus = {}));
+// FIXME: Missing documentation for AssetAccountStatus
+var AssetAccountStatus;
+(function (AssetAccountStatus) {
+    //Initial state of `AssetAccount` entity, indicating that it’s being created at the moment.
+    AssetAccountStatus["Creating"] = "Creating";
+    // FIXME: Missing documentation for Enabled
+    AssetAccountStatus["Enabled"] = "Enabled";
+    // FIXME: Missing documentation for Failed
+    AssetAccountStatus["Failed"] = "Failed";
+})(AssetAccountStatus = exports.AssetAccountStatus || (exports.AssetAccountStatus = {}));
+// FIXME: Missing documentation for PaymentStatus
+var PaymentStatus;
+(function (PaymentStatus) {
+    //Payment order is received and initiated. It will execute later.
+    PaymentStatus["Initiated"] = "Initiated";
+    //Some Policy blocked the payment, it is not approved.
+    PaymentStatus["Rejected"] = "Rejected";
+    //Payment passed Policies, it is approved.
+    PaymentStatus["Approved"] = "Approved";
+    //Payment is successfully Executed and Broadcasted on the blockchain.
+    PaymentStatus["Executed"] = "Executed";
+    //Payment tried to execute, but failed doing so.
+    PaymentStatus["Failed"] = "Failed";
+    //Payment transaction is confirmed on the blockchain.
+    PaymentStatus["Confirmed"] = "Confirmed";
+})(PaymentStatus = exports.PaymentStatus || (exports.PaymentStatus = {}));
+// FIXME: Missing documentation for AssetAccountAuthorizationKind
+var AssetAccountAuthorizationKind;
+(function (AssetAccountAuthorizationKind) {
+    // FIXME: Missing documentation for Employee
+    AssetAccountAuthorizationKind["Employee"] = "Employee";
+    // FIXME: Missing documentation for Group
+    AssetAccountAuthorizationKind["Group"] = "Group";
+    // FIXME: Missing documentation for ApiKey
+    AssetAccountAuthorizationKind["ApiKey"] = "ApiKey";
+})(AssetAccountAuthorizationKind = exports.AssetAccountAuthorizationKind || (exports.AssetAccountAuthorizationKind = {}));
+// FIXME: Missing documentation for AssetAccountPermissions
+var AssetAccountPermissions;
+(function (AssetAccountPermissions) {
+    // FIXME: Missing documentation for InitiatePayments
+    AssetAccountPermissions["InitiatePayments"] = "InitiatePayments";
+    // FIXME: Missing documentation for ReadBalance
+    AssetAccountPermissions["ReadBalance"] = "ReadBalance";
+    // FIXME: Missing documentation for ReadPublicKey
+    AssetAccountPermissions["ReadPublicKey"] = "ReadPublicKey";
+})(AssetAccountPermissions = exports.AssetAccountPermissions || (exports.AssetAccountPermissions = {}));
+// FIXME: Missing documentation for PaymentDirection
+var PaymentDirection;
+(function (PaymentDirection) {
+    // FIXME: Missing documentation for Incoming
+    PaymentDirection["Incoming"] = "Incoming";
+    // FIXME: Missing documentation for Outgoing
+    PaymentDirection["Outgoing"] = "Outgoing";
+})(PaymentDirection = exports.PaymentDirection || (exports.PaymentDirection = {}));

package/codegen/datamodel/Auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from './responses';
+export * from './types';

package/codegen/datamodel/Auth/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./responses"), exports);
+__exportStar(require("./types"), exports);

package/codegen/datamodel/Auth/responses.d.ts

@@ -0,0 +1,348 @@
+import { BadRequestError, EntityNotFoundError, ForbiddenError, UnauthorizedError } from '../Foundations';
+import { AccessTokenInfoWithPublicKey, AppInfoWithPublicKey, AvailableOrg, CredentialInfo, GenericSuccessMessage, UserAccessTokenInformation, UserActionSignature, UserCredentialChallenge, UserInfo, UserLogin, UserLoginChallenge, UserRecoveryChallenge, UserRegistration, UserRegistrationChallenge } from './types';
+export type CreateDelegatedUserRegistrationSuccess = UserRegistrationChallenge;
+export type CreateDelegatedUserRegistrationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateDelegatedUserRegistrationResponse = CreateDelegatedUserRegistrationSuccess | CreateDelegatedUserRegistrationError;
+export type CreateUserRegistrationChallengeSuccess = UserRegistrationChallenge;
+export type CreateUserRegistrationChallengeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserRegistrationChallengeResponse = CreateUserRegistrationChallengeSuccess | CreateUserRegistrationChallengeError;
+export type CreateUserRegistrationSuccess = UserRegistration;
+export type CreateUserRegistrationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserRegistrationResponse = CreateUserRegistrationSuccess | CreateUserRegistrationError;
+export type CreateUserLoginChallengeSuccess = UserLoginChallenge;
+export type CreateUserLoginChallengeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserLoginChallengeResponse = CreateUserLoginChallengeSuccess | CreateUserLoginChallengeError;
+export type CreateUserLoginSuccess = UserLogin;
+export type CreateUserLoginError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserLoginResponse = CreateUserLoginSuccess | CreateUserLoginError;
+export type CreateDelegatedUserLoginSuccess = UserLogin;
+export type CreateDelegatedUserLoginError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateDelegatedUserLoginResponse = CreateDelegatedUserLoginSuccess | CreateDelegatedUserLoginError;
+export type CreateUserActionSignatureChallengeSuccess = UserLoginChallenge;
+export type CreateUserActionSignatureChallengeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserActionSignatureChallengeResponse = CreateUserActionSignatureChallengeSuccess | CreateUserActionSignatureChallengeError;
+export type CreateUserActionSignatureSuccess = UserActionSignature;
+export type CreateUserActionSignatureError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserActionSignatureResponse = CreateUserActionSignatureSuccess | CreateUserActionSignatureError;
+export type ResendUserRegistrationEmailSuccess = GenericSuccessMessage;
+export type ResendUserRegistrationEmailError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ResendUserRegistrationEmailResponse = ResendUserRegistrationEmailSuccess | ResendUserRegistrationEmailError;
+export type CreateUserCredentialChallengeSuccess = UserCredentialChallenge;
+export type CreateUserCredentialChallengeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserCredentialChallengeResponse = CreateUserCredentialChallengeSuccess | CreateUserCredentialChallengeError;
+export type CreateUserCredentialSuccess = CredentialInfo;
+export type CreateUserCredentialError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserCredentialResponse = CreateUserCredentialSuccess | CreateUserCredentialError;
+export type ActivateCredentialSuccess = GenericSuccessMessage;
+export type ActivateCredentialError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ActivateCredentialResponse = ActivateCredentialSuccess | ActivateCredentialError;
+export type DeactivateCredentialSuccess = GenericSuccessMessage;
+export type DeactivateCredentialError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type DeactivateCredentialResponse = DeactivateCredentialSuccess | DeactivateCredentialError;
+export type ListUserCredentialsSuccess = {
+    items: CredentialInfo[];
+};
+export type ListUserCredentialsError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListUserCredentialsResponse = ListUserCredentialsSuccess | ListUserCredentialsError;
+export type CreateCodeLoginChallengeSuccess = UserLoginChallenge;
+export type CreateCodeLoginChallengeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateCodeLoginChallengeResponse = CreateCodeLoginChallengeSuccess | CreateCodeLoginChallengeError;
+export type CreateCodeLoginSuccess = GenericSuccessMessage;
+export type CreateCodeLoginError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateCodeLoginResponse = CreateCodeLoginSuccess | CreateCodeLoginError;
+export type CreateUserLoginFromCodeSuccess = UserLogin;
+export type CreateUserLoginFromCodeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserLoginFromCodeResponse = CreateUserLoginFromCodeSuccess | CreateUserLoginFromCodeError;
+export type CreateUserActionSignatureFromCodeSuccess = UserActionSignature;
+export type CreateUserActionSignatureFromCodeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserActionSignatureFromCodeResponse = CreateUserActionSignatureFromCodeSuccess | CreateUserActionSignatureFromCodeError;
+export type CreateCodeUserActionSignatureChallengeSuccess = UserLoginChallenge;
+export type CreateCodeUserActionSignatureChallengeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateCodeUserActionSignatureChallengeResponse = CreateCodeUserActionSignatureChallengeSuccess | CreateCodeUserActionSignatureChallengeError;
+export type CreateCodeUserActionSignatureSuccess = GenericSuccessMessage;
+export type CreateCodeUserActionSignatureError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateCodeUserActionSignatureResponse = CreateCodeUserActionSignatureSuccess | CreateCodeUserActionSignatureError;
+export type CreateAvailableOrgListSuccess = {
+    items: AvailableOrg[];
+};
+export type CreateAvailableOrgListError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateAvailableOrgListResponse = CreateAvailableOrgListSuccess | CreateAvailableOrgListError;
+export type ListPersonalAccessTokensSuccess = {
+    items: AccessTokenInfoWithPublicKey[];
+};
+export type ListPersonalAccessTokensError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListPersonalAccessTokensResponse = ListPersonalAccessTokensSuccess | ListPersonalAccessTokensError;
+export type CreatePersonalAccessTokenSuccess = AccessTokenInfoWithPublicKey;
+export type CreatePersonalAccessTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreatePersonalAccessTokenResponse = CreatePersonalAccessTokenSuccess | CreatePersonalAccessTokenError;
+export type GetPersonalAccessTokensSuccess = AccessTokenInfoWithPublicKey;
+export type GetPersonalAccessTokensError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetPersonalAccessTokensResponse = GetPersonalAccessTokensSuccess | GetPersonalAccessTokensError;
+export type UpdatePersonalAccessTokenSuccess = AccessTokenInfoWithPublicKey;
+export type UpdatePersonalAccessTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type UpdatePersonalAccessTokenResponse = UpdatePersonalAccessTokenSuccess | UpdatePersonalAccessTokenError;
+export type ArchivePersonalAccessTokenSuccess = AccessTokenInfoWithPublicKey;
+export type ArchivePersonalAccessTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ArchivePersonalAccessTokenResponse = ArchivePersonalAccessTokenSuccess | ArchivePersonalAccessTokenError;
+export type ActivatePersonalAccessTokenSuccess = AccessTokenInfoWithPublicKey;
+export type ActivatePersonalAccessTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ActivatePersonalAccessTokenResponse = ActivatePersonalAccessTokenSuccess | ActivatePersonalAccessTokenError;
+export type DeactivatePersonalAccessTokenSuccess = AccessTokenInfoWithPublicKey;
+export type DeactivatePersonalAccessTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type DeactivatePersonalAccessTokenResponse = DeactivatePersonalAccessTokenSuccess | DeactivatePersonalAccessTokenError;
+export type ListServiceAccountsSuccess = {
+    items: UserAccessTokenInformation[];
+};
+export type ListServiceAccountsError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListServiceAccountsResponse = ListServiceAccountsSuccess | ListServiceAccountsError;
+export type CreateServiceAccountSuccess = UserAccessTokenInformation;
+export type CreateServiceAccountError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateServiceAccountResponse = CreateServiceAccountSuccess | CreateServiceAccountError;
+export type GetServiceAccountSuccess = UserAccessTokenInformation;
+export type GetServiceAccountError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetServiceAccountResponse = GetServiceAccountSuccess | GetServiceAccountError;
+export type UpdateServiceAccountSuccess = UserAccessTokenInformation;
+export type UpdateServiceAccountError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type UpdateServiceAccountResponse = UpdateServiceAccountSuccess | UpdateServiceAccountError;
+export type ArchiveServiceAccountSuccess = UserAccessTokenInformation;
+export type ArchiveServiceAccountError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ArchiveServiceAccountResponse = ArchiveServiceAccountSuccess | ArchiveServiceAccountError;
+export type ActivateServiceAccountSuccess = UserAccessTokenInformation;
+export type ActivateServiceAccountError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ActivateServiceAccountResponse = ActivateServiceAccountSuccess | ActivateServiceAccountError;
+export type DeactivateServiceAccountSuccess = UserAccessTokenInformation;
+export type DeactivateServiceAccountError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type DeactivateServiceAccountResponse = DeactivateServiceAccountSuccess | DeactivateServiceAccountError;
+export type ListServiceAccountTokensSuccess = {
+    items: AccessTokenInfoWithPublicKey[];
+};
+export type ListServiceAccountTokensError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListServiceAccountTokensResponse = ListServiceAccountTokensSuccess | ListServiceAccountTokensError;
+export type CreateServiceAccountTokenSuccess = AccessTokenInfoWithPublicKey;
+export type CreateServiceAccountTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateServiceAccountTokenResponse = CreateServiceAccountTokenSuccess | CreateServiceAccountTokenError;
+export type GetServiceAccountTokenSuccess = AccessTokenInfoWithPublicKey;
+export type GetServiceAccountTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetServiceAccountTokenResponse = GetServiceAccountTokenSuccess | GetServiceAccountTokenError;
+export type UpdateServiceAccountTokenSuccess = AccessTokenInfoWithPublicKey;
+export type UpdateServiceAccountTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type UpdateServiceAccountTokenResponse = UpdateServiceAccountTokenSuccess | UpdateServiceAccountTokenError;
+export type ArchiveServiceAccountTokenSuccess = AccessTokenInfoWithPublicKey;
+export type ArchiveServiceAccountTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ArchiveServiceAccountTokenResponse = ArchiveServiceAccountTokenSuccess | ArchiveServiceAccountTokenError;
+export type ActivateServiceAccountTokenSuccess = AccessTokenInfoWithPublicKey;
+export type ActivateServiceAccountTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ActivateServiceAccountTokenResponse = ActivateServiceAccountTokenSuccess | ActivateServiceAccountTokenError;
+export type DeactivateServiceAccountTokenSuccess = AccessTokenInfoWithPublicKey;
+export type DeactivateServiceAccountTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type DeactivateServiceAccountTokenResponse = DeactivateServiceAccountTokenSuccess | DeactivateServiceAccountTokenError;
+export type ListUsersSuccess = {
+    items: UserInfo[];
+};
+export type ListUsersError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListUsersResponse = ListUsersSuccess | ListUsersError;
+export type CreateUserSuccess = UserInfo;
+export type CreateUserError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserResponse = CreateUserSuccess | CreateUserError;
+export type GetUserSuccess = UserInfo;
+export type GetUserError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetUserResponse = GetUserSuccess | GetUserError;
+export type UpdateUserSuccess = UserInfo;
+export type UpdateUserError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type UpdateUserResponse = UpdateUserSuccess | UpdateUserError;
+export type ArchiveUserSuccess = UserInfo;
+export type ArchiveUserError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ArchiveUserResponse = ArchiveUserSuccess | ArchiveUserError;
+export type ActivateUserSuccess = UserInfo;
+export type ActivateUserError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ActivateUserResponse = ActivateUserSuccess | ActivateUserError;
+export type DeactivateUserSuccess = UserInfo;
+export type DeactivateUserError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type DeactivateUserResponse = DeactivateUserSuccess | DeactivateUserError;
+export type ListApplicationsSuccess = {
+    items: AppInfoWithPublicKey[];
+};
+export type ListApplicationsError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListApplicationsResponse = ListApplicationsSuccess | ListApplicationsError;
+export type CreateApplicationSuccess = AppInfoWithPublicKey;
+export type CreateApplicationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateApplicationResponse = CreateApplicationSuccess | CreateApplicationError;
+export type GetApplicationSuccess = AppInfoWithPublicKey;
+export type GetApplicationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetApplicationResponse = GetApplicationSuccess | GetApplicationError;
+export type UpdateApplicationSuccess = AppInfoWithPublicKey;
+export type UpdateApplicationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type UpdateApplicationResponse = UpdateApplicationSuccess | UpdateApplicationError;
+export type ArchiveApplicationSuccess = AppInfoWithPublicKey;
+export type ArchiveApplicationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ArchiveApplicationResponse = ArchiveApplicationSuccess | ArchiveApplicationError;
+export type ActivateApplicationSuccess = AppInfoWithPublicKey;
+export type ActivateApplicationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ActivateApplicationResponse = ActivateApplicationSuccess | ActivateApplicationError;
+export type DeactivateApplicationSuccess = AppInfoWithPublicKey;
+export type DeactivateApplicationError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type DeactivateApplicationResponse = DeactivateApplicationSuccess | DeactivateApplicationError;
+export type ListApplicationTokensSuccess = {
+    items: AccessTokenInfoWithPublicKey[];
+};
+export type ListApplicationTokensError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListApplicationTokensResponse = ListApplicationTokensSuccess | ListApplicationTokensError;
+export type CreateApplicationTokenSuccess = AccessTokenInfoWithPublicKey;
+export type CreateApplicationTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateApplicationTokenResponse = CreateApplicationTokenSuccess | CreateApplicationTokenError;
+export type GetApplicationTokenSuccess = AccessTokenInfoWithPublicKey;
+export type GetApplicationTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetApplicationTokenResponse = GetApplicationTokenSuccess | GetApplicationTokenError;
+export type UpdateApplicationTokenSuccess = AccessTokenInfoWithPublicKey;
+export type UpdateApplicationTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type UpdateApplicationTokenResponse = UpdateApplicationTokenSuccess | UpdateApplicationTokenError;
+export type ArchiveApplicationTokenSuccess = AccessTokenInfoWithPublicKey;
+export type ArchiveApplicationTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ArchiveApplicationTokenResponse = ArchiveApplicationTokenSuccess | ArchiveApplicationTokenError;
+export type ActivateApplicationTokenSuccess = AccessTokenInfoWithPublicKey;
+export type ActivateApplicationTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ActivateApplicationTokenResponse = ActivateApplicationTokenSuccess | ActivateApplicationTokenError;
+export type DeactivateApplicationTokenSuccess = AccessTokenInfoWithPublicKey;
+export type DeactivateApplicationTokenError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type DeactivateApplicationTokenResponse = DeactivateApplicationTokenSuccess | DeactivateApplicationTokenError;
+export type CreateUserRecoveryChallengeSuccess = UserRecoveryChallenge;
+export type CreateUserRecoveryChallengeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserRecoveryChallengeResponse = CreateUserRecoveryChallengeSuccess | CreateUserRecoveryChallengeError;
+export type CreateUserRecoveryCodeSuccess = GenericSuccessMessage;
+export type CreateUserRecoveryCodeError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserRecoveryCodeResponse = CreateUserRecoveryCodeSuccess | CreateUserRecoveryCodeError;
+export type CreateUserRecoverySuccess = UserRegistration;
+export type CreateUserRecoveryError = {
+    error: UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateUserRecoveryResponse = CreateUserRecoverySuccess | CreateUserRecoveryError;

package/codegen/datamodel/Auth/responses.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });