@shipload/sdk 0.0.0

package/README.md

@@ -0,0 +1 @@
+# SDK

package/lib/shipload.d.ts

@@ -0,0 +1,332 @@
+import { Checksum256Type, Blob, ABI, Struct, Name, UInt64, NameType, UInt64Type, Action, Int64, Checksum256, UInt16, UInt32, UInt8, BlockTimestamp, Int64Type, Checksum512 } from '@wharfkit/antelope';
+import { Contract as Contract$2, PartialBy, ContractArgs, ActionOptions, Table } from '@wharfkit/contract';
+
+declare function hash(seed: Checksum256Type, string: string): string;
+
+declare const abiBlob$1: Blob;
+declare const abi$1: ABI;
+declare namespace Types$1 {
+    class cleartable extends Struct {
+        table_name: Name;
+        scope?: Name;
+        max_rows?: UInt64;
+    }
+    class company_row extends Struct {
+        account: Name;
+        name: string;
+    }
+    class enable extends Struct {
+        enabled: boolean;
+    }
+    class foundcompany extends Struct {
+        account: Name;
+        name: string;
+    }
+    class state_row extends Struct {
+        enabled: boolean;
+    }
+    class test extends Struct {
+        data: string;
+    }
+    class wipe extends Struct {
+    }
+}
+declare const TableMap$1: {
+    company: typeof Types$1.company_row;
+    state: typeof Types$1.state_row;
+};
+interface TableTypes$1 {
+    company: Types$1.company_row;
+    state: Types$1.state_row;
+}
+type RowType$1<T> = T extends keyof TableTypes$1 ? TableTypes$1[T] : any;
+type TableNames$1 = keyof TableTypes$1;
+declare namespace ActionParams$1 {
+    namespace Type { }
+    interface cleartable {
+        table_name: NameType;
+        scope?: NameType;
+        max_rows?: UInt64Type;
+    }
+    interface enable {
+        enabled: boolean;
+    }
+    interface foundcompany {
+        account: NameType;
+        name: string;
+    }
+    interface test {
+        data: string;
+    }
+    interface wipe {
+    }
+}
+interface ActionNameParams$1 {
+    cleartable: ActionParams$1.cleartable;
+    enable: ActionParams$1.enable;
+    foundcompany: ActionParams$1.foundcompany;
+    test: ActionParams$1.test;
+    wipe: ActionParams$1.wipe;
+}
+type ActionNames$1 = keyof ActionNameParams$1;
+declare class Contract$1 extends Contract$2 {
+    constructor(args: PartialBy<ContractArgs, 'abi' | 'account'>);
+    action<T extends ActionNames$1>(name: T, data: ActionNameParams$1[T], options?: ActionOptions): Action;
+    table<T extends TableNames$1>(name: T, scope?: NameType): Table<RowType$1<T>>;
+}
+
+declare namespace platform {
+  export {
+    abiBlob$1 as abiBlob,
+    abi$1 as abi,
+    Types$1 as Types,
+    TableMap$1 as TableMap,
+    TableTypes$1 as TableTypes,
+    RowType$1 as RowType,
+    TableNames$1 as TableNames,
+    ActionParams$1 as ActionParams,
+    ActionNameParams$1 as ActionNameParams,
+    ActionNames$1 as ActionNames,
+    Contract$1 as Contract,
+  };
+}
+
+declare const abiBlob: Blob;
+declare const abi: ABI;
+declare namespace Types {
+    class advance extends Struct {
+    }
+    class arrive extends Struct {
+        owner: Name;
+        id: UInt64;
+    }
+    class cleartable extends Struct {
+        table_name: Name;
+        scope?: Name;
+        max_rows?: UInt64;
+    }
+    class coordinates extends Struct {
+        x: Int64;
+        y: Int64;
+    }
+    class enable extends Struct {
+        enabled: boolean;
+    }
+    class esttravel extends Struct {
+        id: UInt64;
+        destination: coordinates;
+    }
+    class hash extends Struct {
+        value: string;
+    }
+    class init extends Struct {
+        seed: Checksum256;
+        epochseed: Checksum256;
+    }
+    class join extends Struct {
+        account: Name;
+    }
+    class loader_stats extends Struct {
+        capacity: UInt16;
+        mass: UInt32;
+        quantity: UInt16;
+        thrust: UInt32;
+    }
+    class player_row extends Struct {
+        owner: Name;
+        balance: UInt64;
+        debt: UInt64;
+    }
+    class sequence_row extends Struct {
+        key: Name;
+        value: UInt64;
+    }
+    class ship_stats extends Struct {
+        capacity: UInt32;
+        drain: UInt32;
+        energy: UInt32;
+        mass: UInt64;
+        orbit: UInt16;
+        recharge: UInt32;
+        thrust: UInt64;
+    }
+    class ship_row extends Struct {
+        id: UInt64;
+        owner: Name;
+        name: string;
+        location: coordinates;
+        skin: UInt8;
+        tier: UInt8;
+        stats: ship_stats;
+        loaders: loader_stats;
+    }
+    class state_row extends Struct {
+        enabled: boolean;
+        epoch: UInt64;
+        epochseed: Checksum256;
+        genesis: BlockTimestamp;
+        seed: Checksum256;
+    }
+    class travel_summary extends Struct {
+        stats: ship_stats;
+        loaders: loader_stats;
+        origin: coordinates;
+        destination: coordinates;
+        distance: UInt64;
+        totalmass: UInt64;
+        acceleration: UInt64;
+        flighttime: UInt64;
+        energyusage: UInt64;
+        rechargetime: UInt64;
+        loadtime: UInt64;
+        time: UInt64;
+    }
+    class summary_row extends Struct {
+        key: Name;
+        value: travel_summary;
+    }
+    class test extends Struct {
+        data: string;
+    }
+    class travel extends Struct {
+        owner: Name;
+        id: UInt64;
+        destination: coordinates;
+        recharge: boolean;
+    }
+    class travelplan_row extends Struct {
+        id: UInt64;
+        departure: BlockTimestamp;
+        destination: coordinates;
+        duration: UInt32;
+    }
+    class wipe extends Struct {
+    }
+}
+declare const TableMap: {
+    player: typeof Types.player_row;
+    sequence: typeof Types.sequence_row;
+    ship: typeof Types.ship_row;
+    state: typeof Types.state_row;
+    summary: typeof Types.summary_row;
+    travelplan: typeof Types.travelplan_row;
+};
+interface TableTypes {
+    player: Types.player_row;
+    sequence: Types.sequence_row;
+    ship: Types.ship_row;
+    state: Types.state_row;
+    summary: Types.summary_row;
+    travelplan: Types.travelplan_row;
+}
+type RowType<T> = T extends keyof TableTypes ? TableTypes[T] : any;
+type TableNames = keyof TableTypes;
+declare namespace ActionParams {
+    namespace Type {
+        interface coordinates {
+            x: Int64Type;
+            y: Int64Type;
+        }
+    }
+    interface advance {
+    }
+    interface arrive {
+        owner: NameType;
+        id: UInt64Type;
+    }
+    interface cleartable {
+        table_name: NameType;
+        scope?: NameType;
+        max_rows?: UInt64Type;
+    }
+    interface enable {
+        enabled: boolean;
+    }
+    interface esttravel {
+        id: UInt64Type;
+        destination: Type.coordinates;
+    }
+    interface hash {
+        value: string;
+    }
+    interface init {
+        seed: Checksum256Type;
+        epochseed: Checksum256Type;
+    }
+    interface join {
+        account: NameType;
+    }
+    interface test {
+        data: string;
+    }
+    interface travel {
+        owner: NameType;
+        id: UInt64Type;
+        destination: Type.coordinates;
+        recharge: boolean;
+    }
+    interface wipe {
+    }
+}
+interface ActionNameParams {
+    advance: ActionParams.advance;
+    arrive: ActionParams.arrive;
+    cleartable: ActionParams.cleartable;
+    enable: ActionParams.enable;
+    esttravel: ActionParams.esttravel;
+    hash: ActionParams.hash;
+    init: ActionParams.init;
+    join: ActionParams.join;
+    test: ActionParams.test;
+    travel: ActionParams.travel;
+    wipe: ActionParams.wipe;
+}
+type ActionNames = keyof ActionNameParams;
+interface ActionReturnValues {
+    esttravel: Types.travel_summary;
+    hash: Checksum512;
+}
+type ActionReturnNames = keyof ActionReturnValues;
+declare class Contract extends Contract$2 {
+    constructor(args: PartialBy<ContractArgs, 'abi' | 'account'>);
+    action<T extends ActionNames>(name: T, data: ActionNameParams[T], options?: ActionOptions): Action;
+    readonly<T extends ActionReturnNames>(name: T, data?: ActionNameParams[T]): ActionReturnValues[T];
+    table<T extends TableNames>(name: T, scope?: NameType): Table<RowType<T>>;
+}
+
+declare const server_abiBlob: typeof abiBlob;
+declare const server_abi: typeof abi;
+declare const server_Types: typeof Types;
+declare const server_TableMap: typeof TableMap;
+type server_TableTypes = TableTypes;
+type server_RowType<T> = RowType<T>;
+type server_TableNames = TableNames;
+declare const server_ActionParams: typeof ActionParams;
+type server_ActionNameParams = ActionNameParams;
+type server_ActionNames = ActionNames;
+type server_ActionReturnValues = ActionReturnValues;
+type server_ActionReturnNames = ActionReturnNames;
+type server_Contract = Contract;
+declare const server_Contract: typeof Contract;
+declare namespace server {
+  export {
+    server_abiBlob as abiBlob,
+    server_abi as abi,
+    server_Types as Types,
+    server_TableMap as TableMap,
+    server_TableTypes as TableTypes,
+    server_RowType as RowType,
+    server_TableNames as TableNames,
+    server_ActionParams as ActionParams,
+    server_ActionNameParams as ActionNameParams,
+    server_ActionNames as ActionNames,
+    server_ActionReturnValues as ActionReturnValues,
+    server_ActionReturnNames as ActionReturnNames,
+    server_Contract as Contract,
+  };
+}
+
+declare class Shipload {
+}
+
+export { platform as PlatformContract, server as ServerContract, Shipload as default, hash };