@typemove/aptos 1.5.6-rc.1 → 1.5.6-rc.2

package/dist/cjs/builtin/0x1.d.ts

@@ -100,6 +100,18 @@ export declare namespace code {
         data_decoded: PackageRegistry;
         type_arguments: [];
     }
+    interface PublishPackage {
+        code_address: MoveAddressType;
+        is_upgrade: Boolean;
+    }
+    namespace PublishPackage {
+        const TYPE_QNAME = "0x1::code::PublishPackage";
+        function type(): TypeDescriptor<PublishPackage>;
+    }
+    interface PublishPackageInstance extends TypedEventInstance<PublishPackage> {
+        data_decoded: PublishPackage;
+        type_arguments: [];
+    }
     interface UpgradePolicy {
         policy: number;
     }
@@ -283,6 +295,185 @@ export declare namespace hash {
     namespace entry { }
     namespace view { }
 }
+export declare namespace jwks {
+    interface AllProvidersJWKs {
+        entries: jwks.ProviderJWKs[];
+    }
+    namespace AllProvidersJWKs {
+        const TYPE_QNAME = "0x1::jwks::AllProvidersJWKs";
+        function type(): TypeDescriptor<AllProvidersJWKs>;
+    }
+    interface AllProvidersJWKsInstance extends TypedEventInstance<AllProvidersJWKs> {
+        data_decoded: AllProvidersJWKs;
+        type_arguments: [];
+    }
+    interface JWK {
+        variant: copyable_any.Any;
+    }
+    namespace JWK {
+        const TYPE_QNAME = "0x1::jwks::JWK";
+        function type(): TypeDescriptor<JWK>;
+    }
+    interface JWKInstance extends TypedEventInstance<JWK> {
+        data_decoded: JWK;
+        type_arguments: [];
+    }
+    interface OIDCProvider {
+        name: string;
+        config_url: string;
+    }
+    namespace OIDCProvider {
+        const TYPE_QNAME = "0x1::jwks::OIDCProvider";
+        function type(): TypeDescriptor<OIDCProvider>;
+    }
+    interface OIDCProviderInstance extends TypedEventInstance<OIDCProvider> {
+        data_decoded: OIDCProvider;
+        type_arguments: [];
+    }
+    interface ObservedJWKs {
+        jwks: jwks.AllProvidersJWKs;
+    }
+    namespace ObservedJWKs {
+        const TYPE_QNAME = "0x1::jwks::ObservedJWKs";
+        function type(): TypeDescriptor<ObservedJWKs>;
+    }
+    interface ObservedJWKsInstance extends TypedEventInstance<ObservedJWKs> {
+        data_decoded: ObservedJWKs;
+        type_arguments: [];
+    }
+    interface ObservedJWKsUpdated {
+        epoch: bigint;
+        jwks: jwks.AllProvidersJWKs;
+    }
+    namespace ObservedJWKsUpdated {
+        const TYPE_QNAME = "0x1::jwks::ObservedJWKsUpdated";
+        function type(): TypeDescriptor<ObservedJWKsUpdated>;
+    }
+    interface ObservedJWKsUpdatedInstance extends TypedEventInstance<ObservedJWKsUpdated> {
+        data_decoded: ObservedJWKsUpdated;
+        type_arguments: [];
+    }
+    interface Patch {
+        variant: copyable_any.Any;
+    }
+    namespace Patch {
+        const TYPE_QNAME = "0x1::jwks::Patch";
+        function type(): TypeDescriptor<Patch>;
+    }
+    interface PatchInstance extends TypedEventInstance<Patch> {
+        data_decoded: Patch;
+        type_arguments: [];
+    }
+    interface PatchRemoveAll {
+        dummy_field: Boolean;
+    }
+    namespace PatchRemoveAll {
+        const TYPE_QNAME = "0x1::jwks::PatchRemoveAll";
+        function type(): TypeDescriptor<PatchRemoveAll>;
+    }
+    interface PatchRemoveAllInstance extends TypedEventInstance<PatchRemoveAll> {
+        data_decoded: PatchRemoveAll;
+        type_arguments: [];
+    }
+    interface PatchRemoveIssuer {
+        issuer: string;
+    }
+    namespace PatchRemoveIssuer {
+        const TYPE_QNAME = "0x1::jwks::PatchRemoveIssuer";
+        function type(): TypeDescriptor<PatchRemoveIssuer>;
+    }
+    interface PatchRemoveIssuerInstance extends TypedEventInstance<PatchRemoveIssuer> {
+        data_decoded: PatchRemoveIssuer;
+        type_arguments: [];
+    }
+    interface PatchRemoveJWK {
+        issuer: string;
+        jwk_id: string;
+    }
+    namespace PatchRemoveJWK {
+        const TYPE_QNAME = "0x1::jwks::PatchRemoveJWK";
+        function type(): TypeDescriptor<PatchRemoveJWK>;
+    }
+    interface PatchRemoveJWKInstance extends TypedEventInstance<PatchRemoveJWK> {
+        data_decoded: PatchRemoveJWK;
+        type_arguments: [];
+    }
+    interface PatchUpsertJWK {
+        issuer: string;
+        jwk: jwks.JWK;
+    }
+    namespace PatchUpsertJWK {
+        const TYPE_QNAME = "0x1::jwks::PatchUpsertJWK";
+        function type(): TypeDescriptor<PatchUpsertJWK>;
+    }
+    interface PatchUpsertJWKInstance extends TypedEventInstance<PatchUpsertJWK> {
+        data_decoded: PatchUpsertJWK;
+        type_arguments: [];
+    }
+    interface PatchedJWKs {
+        jwks: jwks.AllProvidersJWKs;
+    }
+    namespace PatchedJWKs {
+        const TYPE_QNAME = "0x1::jwks::PatchedJWKs";
+        function type(): TypeDescriptor<PatchedJWKs>;
+    }
+    interface Patches {
+        patches: jwks.Patch[];
+    }
+    namespace Patches {
+        const TYPE_QNAME = "0x1::jwks::Patches";
+        function type(): TypeDescriptor<Patches>;
+    }
+    interface ProviderJWKs {
+        issuer: string;
+        version: bigint;
+        jwks: jwks.JWK[];
+    }
+    namespace ProviderJWKs {
+        const TYPE_QNAME = "0x1::jwks::ProviderJWKs";
+        function type(): TypeDescriptor<ProviderJWKs>;
+    }
+    interface ProviderJWKsInstance extends TypedEventInstance<ProviderJWKs> {
+        data_decoded: ProviderJWKs;
+        type_arguments: [];
+    }
+    interface RSA_JWK {
+        kid: string;
+        kty: string;
+        alg: string;
+        e: string;
+        n: string;
+    }
+    namespace RSA_JWK {
+        const TYPE_QNAME = "0x1::jwks::RSA_JWK";
+        function type(): TypeDescriptor<RSA_JWK>;
+    }
+    interface RSA_JWKInstance extends TypedEventInstance<RSA_JWK> {
+        data_decoded: RSA_JWK;
+        type_arguments: [];
+    }
+    interface SupportedOIDCProviders {
+        providers: jwks.OIDCProvider[];
+    }
+    namespace SupportedOIDCProviders {
+        const TYPE_QNAME = "0x1::jwks::SupportedOIDCProviders";
+        function type(): TypeDescriptor<SupportedOIDCProviders>;
+    }
+    interface UnsupportedJWK {
+        id: string;
+        payload: string;
+    }
+    namespace UnsupportedJWK {
+        const TYPE_QNAME = "0x1::jwks::UnsupportedJWK";
+        function type(): TypeDescriptor<UnsupportedJWK>;
+    }
+    interface UnsupportedJWKInstance extends TypedEventInstance<UnsupportedJWK> {
+        data_decoded: UnsupportedJWK;
+        type_arguments: [];
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace util {
     namespace entry { }
     namespace view { }
@@ -1208,6 +1399,10 @@ export declare namespace account {
             typeArguments: [];
             functionArguments: [number, string, number, string, string, string];
         }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function rotateAuthenticationKeyCall(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
         function rotateAuthenticationKeyWithRotationCapability(client: Aptos, account: AptosAccount, request: {
             typeArguments: [];
             functionArguments: [MoveAddressType, number, string, string];
@@ -2323,6 +2518,18 @@ export declare namespace aggregator_v2 {
         data_decoded: AggregatorSnapshot<any>;
         type_arguments: [string];
     }
+    interface DerivedStringSnapshot {
+        value: string;
+        padding: string;
+    }
+    namespace DerivedStringSnapshot {
+        const TYPE_QNAME = "0x1::aggregator_v2::DerivedStringSnapshot";
+        function type(): TypeDescriptor<DerivedStringSnapshot>;
+    }
+    interface DerivedStringSnapshotInstance extends TypedEventInstance<DerivedStringSnapshot> {
+        data_decoded: DerivedStringSnapshot;
+        type_arguments: [];
+    }
     namespace entry { }
     namespace view { }
 }
@@ -3207,6 +3414,42 @@ export declare namespace delegation_pool {
         }, version?: bigint): Promise<[bigint]>;
     }
 }
+export declare namespace keyless_account {
+    interface Configuration {
+        override_aud_vals: string[];
+        max_signatures_per_txn: number;
+        max_exp_horizon_secs: bigint;
+        training_wheels_pubkey: option.Option<string>;
+        max_commited_epk_bytes: number;
+        max_iss_val_bytes: number;
+        max_extra_field_bytes: number;
+        max_jwt_header_b64_bytes: number;
+    }
+    namespace Configuration {
+        const TYPE_QNAME = "0x1::keyless_account::Configuration";
+        function type(): TypeDescriptor<Configuration>;
+    }
+    interface Groth16VerificationKey {
+        alpha_g1: string;
+        beta_g2: string;
+        gamma_g2: string;
+        delta_g2: string;
+        gamma_abc_g1: string[];
+    }
+    namespace Groth16VerificationKey {
+        const TYPE_QNAME = "0x1::keyless_account::Groth16VerificationKey";
+        function type(): TypeDescriptor<Groth16VerificationKey>;
+    }
+    interface Group {
+        dummy_field: Boolean;
+    }
+    namespace Group {
+        const TYPE_QNAME = "0x1::keyless_account::Group";
+        function type(): TypeDescriptor<Group>;
+    }
+    namespace entry { }
+    namespace view { }
+}
 export declare namespace reconfiguration {
     interface Configuration {
         epoch: bigint;
@@ -4323,6 +4566,67 @@ export declare namespace ristretto255_pedersen {
     namespace entry { }
     namespace view { }
 }
+export declare namespace object_code_deployment {
+    interface Freeze {
+        object_address: MoveAddressType;
+    }
+    namespace Freeze {
+        const TYPE_QNAME = "0x1::object_code_deployment::Freeze";
+        function type(): TypeDescriptor<Freeze>;
+    }
+    interface FreezeInstance extends TypedEventInstance<Freeze> {
+        data_decoded: Freeze;
+        type_arguments: [];
+    }
+    interface ManagingRefs {
+        extend_ref: object_.ExtendRef;
+    }
+    namespace ManagingRefs {
+        const TYPE_QNAME = "0x1::object_code_deployment::ManagingRefs";
+        function type(): TypeDescriptor<ManagingRefs>;
+    }
+    interface Publish {
+        object_address: MoveAddressType;
+    }
+    namespace Publish {
+        const TYPE_QNAME = "0x1::object_code_deployment::Publish";
+        function type(): TypeDescriptor<Publish>;
+    }
+    interface PublishInstance extends TypedEventInstance<Publish> {
+        data_decoded: Publish;
+        type_arguments: [];
+    }
+    interface Upgrade {
+        object_address: MoveAddressType;
+    }
+    namespace Upgrade {
+        const TYPE_QNAME = "0x1::object_code_deployment::Upgrade";
+        function type(): TypeDescriptor<Upgrade>;
+    }
+    interface UpgradeInstance extends TypedEventInstance<Upgrade> {
+        data_decoded: Upgrade;
+        type_arguments: [];
+    }
+    namespace entry {
+        function freezeCodeObject(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [object_.Object<code.PackageRegistry>];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function publish(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [string, string[]];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+        function upgrade(client: Aptos, account: AptosAccount, request: {
+            typeArguments: [];
+            functionArguments: [
+                string,
+                string[],
+                object_.Object<code.PackageRegistry>
+            ];
+        }, options?: InputGenerateTransactionOptions): Promise<PendingTransactionResponse>;
+    }
+    namespace view { }
+}
 export declare namespace primary_fungible_store {
     interface DeriveRefPod {
         metadata_derive_ref: object_.DeriveRef;