@typus/typus-sdk 1.4.84 → 1.5.1

package/dist/src/typus-perp/_dependencies/source/0x2/deny-list/structs.d.ts

@@ -0,0 +1,430 @@
+import * as reified from "../../../../_framework/reified";
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr, ToTypeStr as ToPhantom } from "../../../../_framework/reified";
+import { FieldsWithTypes } from "../../../../_framework/util";
+import { Vector } from "../../../../_framework/vector";
+import { Bag } from "../bag/structs";
+import { PKG_V26 } from "../index";
+import { ID, UID } from "../object/structs";
+import { Table } from "../table/structs";
+import { VecSet } from "../vec-set/structs";
+import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+export declare function isAddressKey(type: string): boolean;
+export interface AddressKeyFields {
+    pos0: ToField<"address">;
+}
+export type AddressKeyReified = Reified<AddressKey, AddressKeyFields>;
+export declare class AddressKey implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x2::deny_list::AddressKey";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x2::deny_list::AddressKey";
+    readonly $fullTypeName: `${typeof PKG_V26}::deny_list::AddressKey`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly pos0: ToField<"address">;
+    private constructor();
+    static reified(): AddressKeyReified;
+    static get r(): reified.StructClassReified<AddressKey, AddressKeyFields>;
+    static phantom(): PhantomReified<ToTypeStr<AddressKey>>;
+    static get p(): reified.PhantomReified<"0x2::deny_list::AddressKey">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        pos0: string;
+    }, {
+        pos0: string;
+    }>;
+    static fromFields(fields: Record<string, any>): AddressKey;
+    static fromFieldsWithTypes(item: FieldsWithTypes): AddressKey;
+    static fromBcs(data: Uint8Array): AddressKey;
+    toJSONField(): {
+        pos0: string;
+    };
+    toJSON(): {
+        pos0: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): AddressKey;
+    static fromJSON(json: Record<string, any>): AddressKey;
+    static fromSuiParsedData(content: SuiParsedData): AddressKey;
+    static fromSuiObjectData(data: SuiObjectData): AddressKey;
+    static fetch(client: SuiClient, id: string): Promise<AddressKey>;
+}
+export declare function isConfigKey(type: string): boolean;
+export interface ConfigKeyFields {
+    perTypeIndex: ToField<"u64">;
+    perTypeKey: ToField<Vector<"u8">>;
+}
+export type ConfigKeyReified = Reified<ConfigKey, ConfigKeyFields>;
+export declare class ConfigKey implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x2::deny_list::ConfigKey";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x2::deny_list::ConfigKey";
+    readonly $fullTypeName: `${typeof PKG_V26}::deny_list::ConfigKey`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly perTypeIndex: ToField<"u64">;
+    readonly perTypeKey: ToField<Vector<"u8">>;
+    private constructor();
+    static reified(): ConfigKeyReified;
+    static get r(): reified.StructClassReified<ConfigKey, ConfigKeyFields>;
+    static phantom(): PhantomReified<ToTypeStr<ConfigKey>>;
+    static get p(): reified.PhantomReified<"0x2::deny_list::ConfigKey">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        per_type_index: string;
+        per_type_key: number[];
+    }, {
+        per_type_index: string | number | bigint;
+        per_type_key: Iterable<number> & {
+            length: number;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): ConfigKey;
+    static fromFieldsWithTypes(item: FieldsWithTypes): ConfigKey;
+    static fromBcs(data: Uint8Array): ConfigKey;
+    toJSONField(): {
+        perTypeIndex: string;
+        perTypeKey: number[];
+    };
+    toJSON(): {
+        perTypeIndex: string;
+        perTypeKey: number[];
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): ConfigKey;
+    static fromJSON(json: Record<string, any>): ConfigKey;
+    static fromSuiParsedData(content: SuiParsedData): ConfigKey;
+    static fromSuiObjectData(data: SuiObjectData): ConfigKey;
+    static fetch(client: SuiClient, id: string): Promise<ConfigKey>;
+}
+export declare function isConfigWriteCap(type: string): boolean;
+export interface ConfigWriteCapFields {
+    dummyField: ToField<"bool">;
+}
+export type ConfigWriteCapReified = Reified<ConfigWriteCap, ConfigWriteCapFields>;
+export declare class ConfigWriteCap implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x2::deny_list::ConfigWriteCap";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x2::deny_list::ConfigWriteCap";
+    readonly $fullTypeName: `${typeof PKG_V26}::deny_list::ConfigWriteCap`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly dummyField: ToField<"bool">;
+    private constructor();
+    static reified(): ConfigWriteCapReified;
+    static get r(): reified.StructClassReified<ConfigWriteCap, ConfigWriteCapFields>;
+    static phantom(): PhantomReified<ToTypeStr<ConfigWriteCap>>;
+    static get p(): reified.PhantomReified<"0x2::deny_list::ConfigWriteCap">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        dummy_field: boolean;
+    }, {
+        dummy_field: boolean;
+    }>;
+    static fromFields(fields: Record<string, any>): ConfigWriteCap;
+    static fromFieldsWithTypes(item: FieldsWithTypes): ConfigWriteCap;
+    static fromBcs(data: Uint8Array): ConfigWriteCap;
+    toJSONField(): {
+        dummyField: boolean;
+    };
+    toJSON(): {
+        dummyField: boolean;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): ConfigWriteCap;
+    static fromJSON(json: Record<string, any>): ConfigWriteCap;
+    static fromSuiParsedData(content: SuiParsedData): ConfigWriteCap;
+    static fromSuiObjectData(data: SuiObjectData): ConfigWriteCap;
+    static fetch(client: SuiClient, id: string): Promise<ConfigWriteCap>;
+}
+export declare function isDenyList(type: string): boolean;
+export interface DenyListFields {
+    id: ToField<UID>;
+    lists: ToField<Bag>;
+}
+export type DenyListReified = Reified<DenyList, DenyListFields>;
+export declare class DenyList implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x2::deny_list::DenyList";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x2::deny_list::DenyList";
+    readonly $fullTypeName: `${typeof PKG_V26}::deny_list::DenyList`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly id: ToField<UID>;
+    readonly lists: ToField<Bag>;
+    private constructor();
+    static reified(): DenyListReified;
+    static get r(): reified.StructClassReified<DenyList, DenyListFields>;
+    static phantom(): PhantomReified<ToTypeStr<DenyList>>;
+    static get p(): reified.PhantomReified<"0x2::deny_list::DenyList">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        lists: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        lists: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): DenyList;
+    static fromFieldsWithTypes(item: FieldsWithTypes): DenyList;
+    static fromBcs(data: Uint8Array): DenyList;
+    toJSONField(): {
+        id: string;
+        lists: {
+            id: string;
+            size: string;
+        };
+    };
+    toJSON(): {
+        id: string;
+        lists: {
+            id: string;
+            size: string;
+        };
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): DenyList;
+    static fromJSON(json: Record<string, any>): DenyList;
+    static fromSuiParsedData(content: SuiParsedData): DenyList;
+    static fromSuiObjectData(data: SuiObjectData): DenyList;
+    static fetch(client: SuiClient, id: string): Promise<DenyList>;
+}
+export declare function isGlobalPauseKey(type: string): boolean;
+export interface GlobalPauseKeyFields {
+    dummyField: ToField<"bool">;
+}
+export type GlobalPauseKeyReified = Reified<GlobalPauseKey, GlobalPauseKeyFields>;
+export declare class GlobalPauseKey implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x2::deny_list::GlobalPauseKey";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x2::deny_list::GlobalPauseKey";
+    readonly $fullTypeName: `${typeof PKG_V26}::deny_list::GlobalPauseKey`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly dummyField: ToField<"bool">;
+    private constructor();
+    static reified(): GlobalPauseKeyReified;
+    static get r(): reified.StructClassReified<GlobalPauseKey, GlobalPauseKeyFields>;
+    static phantom(): PhantomReified<ToTypeStr<GlobalPauseKey>>;
+    static get p(): reified.PhantomReified<"0x2::deny_list::GlobalPauseKey">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        dummy_field: boolean;
+    }, {
+        dummy_field: boolean;
+    }>;
+    static fromFields(fields: Record<string, any>): GlobalPauseKey;
+    static fromFieldsWithTypes(item: FieldsWithTypes): GlobalPauseKey;
+    static fromBcs(data: Uint8Array): GlobalPauseKey;
+    toJSONField(): {
+        dummyField: boolean;
+    };
+    toJSON(): {
+        dummyField: boolean;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): GlobalPauseKey;
+    static fromJSON(json: Record<string, any>): GlobalPauseKey;
+    static fromSuiParsedData(content: SuiParsedData): GlobalPauseKey;
+    static fromSuiObjectData(data: SuiObjectData): GlobalPauseKey;
+    static fetch(client: SuiClient, id: string): Promise<GlobalPauseKey>;
+}
+export declare function isPerTypeConfigCreated(type: string): boolean;
+export interface PerTypeConfigCreatedFields {
+    key: ToField<ConfigKey>;
+    configId: ToField<ID>;
+}
+export type PerTypeConfigCreatedReified = Reified<PerTypeConfigCreated, PerTypeConfigCreatedFields>;
+export declare class PerTypeConfigCreated implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x2::deny_list::PerTypeConfigCreated";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x2::deny_list::PerTypeConfigCreated";
+    readonly $fullTypeName: `${typeof PKG_V26}::deny_list::PerTypeConfigCreated`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly key: ToField<ConfigKey>;
+    readonly configId: ToField<ID>;
+    private constructor();
+    static reified(): PerTypeConfigCreatedReified;
+    static get r(): reified.StructClassReified<PerTypeConfigCreated, PerTypeConfigCreatedFields>;
+    static phantom(): PhantomReified<ToTypeStr<PerTypeConfigCreated>>;
+    static get p(): reified.PhantomReified<"0x2::deny_list::PerTypeConfigCreated">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        key: {
+            per_type_index: string;
+            per_type_key: number[];
+        };
+        config_id: {
+            bytes: string;
+        };
+    }, {
+        key: {
+            per_type_index: string | number | bigint;
+            per_type_key: Iterable<number> & {
+                length: number;
+            };
+        };
+        config_id: {
+            bytes: string;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): PerTypeConfigCreated;
+    static fromFieldsWithTypes(item: FieldsWithTypes): PerTypeConfigCreated;
+    static fromBcs(data: Uint8Array): PerTypeConfigCreated;
+    toJSONField(): {
+        key: {
+            perTypeIndex: string;
+            perTypeKey: number[];
+        };
+        configId: string;
+    };
+    toJSON(): {
+        key: {
+            perTypeIndex: string;
+            perTypeKey: number[];
+        };
+        configId: string;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): PerTypeConfigCreated;
+    static fromJSON(json: Record<string, any>): PerTypeConfigCreated;
+    static fromSuiParsedData(content: SuiParsedData): PerTypeConfigCreated;
+    static fromSuiObjectData(data: SuiObjectData): PerTypeConfigCreated;
+    static fetch(client: SuiClient, id: string): Promise<PerTypeConfigCreated>;
+}
+export declare function isPerTypeList(type: string): boolean;
+export interface PerTypeListFields {
+    id: ToField<UID>;
+    deniedCount: ToField<Table<"address", "u64">>;
+    deniedAddresses: ToField<Table<ToPhantom<Vector<"u8">>, ToPhantom<VecSet<"address">>>>;
+}
+export type PerTypeListReified = Reified<PerTypeList, PerTypeListFields>;
+export declare class PerTypeList implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0x2::deny_list::PerTypeList";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0x2::deny_list::PerTypeList";
+    readonly $fullTypeName: `${typeof PKG_V26}::deny_list::PerTypeList`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly id: ToField<UID>;
+    readonly deniedCount: ToField<Table<"address", "u64">>;
+    readonly deniedAddresses: ToField<Table<ToPhantom<Vector<"u8">>, ToPhantom<VecSet<"address">>>>;
+    private constructor();
+    static reified(): PerTypeListReified;
+    static get r(): reified.StructClassReified<PerTypeList, PerTypeListFields>;
+    static phantom(): PhantomReified<ToTypeStr<PerTypeList>>;
+    static get p(): reified.PhantomReified<"0x2::deny_list::PerTypeList">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        denied_count: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+        denied_addresses: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        denied_count: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+        denied_addresses: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+    }>;
+    static fromFields(fields: Record<string, any>): PerTypeList;
+    static fromFieldsWithTypes(item: FieldsWithTypes): PerTypeList;
+    static fromBcs(data: Uint8Array): PerTypeList;
+    toJSONField(): {
+        id: string;
+        deniedCount: {
+            id: string;
+            size: string;
+        };
+        deniedAddresses: {
+            id: string;
+            size: string;
+        };
+    };
+    toJSON(): {
+        id: string;
+        deniedCount: {
+            id: string;
+            size: string;
+        };
+        deniedAddresses: {
+            id: string;
+            size: string;
+        };
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): PerTypeList;
+    static fromJSON(json: Record<string, any>): PerTypeList;
+    static fromSuiParsedData(content: SuiParsedData): PerTypeList;
+    static fromSuiObjectData(data: SuiObjectData): PerTypeList;
+    static fetch(client: SuiClient, id: string): Promise<PerTypeList>;
+}