GV

GeezerVison

The World Wide Web, restored to 800 pixels of glory.

Home|About|Gaming cabinet|Archives|How it works|Starter sites

On this site

  • Sign in
  • ActionsCI/CD and automation
  • CodespacesCloud development environments
  • All Features
  • Documentation
  • Training
  • Certifications
  • Build with Copilot
  • Customize Copilot
  • Integrations
  • Trending repos
  • GitHub Sponsors
  • Developer articles
  • Enterprises

This view

  • Original page
  • New address

GeezerVison is showing github.com — NativeScript/declarations.ios.d.ts at master · railsdev/NativeScript

Expand file tree

/

declarations.ios.d.ts

Copy path
More file actions
More file actions

Latest commit

 

History

History
History
104 lines (90 loc) · 2.69 KB
/

declarations.ios.d.ts

Copy path

File metadata and controls

104 lines (90 loc) · 2.69 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
/* tslint:disable:no-unused-variable */
/**
* Provides API for working with native C types, pointers, pointer arithmetic and memory.
*/
declare module interop {
/**
* A type that wraps a pointer and allows read/write operations on its value.
*/
interface Reference<T> {
value: T;
}
/**
* A Reference constructor.
*/
var Reference: {
/**
* Creates a new reference around a value.
* The native representation of the type will be determined the first time the Reference is used
* in operation involving marshalling.
* @param value The JavaScript value used to initialize the reference.
*/
new <T>(value?: T): Reference<T>;
/**
* Creates a reference from to the pointer with a given type.
* @param type The type to interpret the pointer
*/
new <T>(type: Type<T>, data: Pointer): Reference<T>;
/**
* Creates a new reference around a value.
* @param type The type to interpret the value
*/
new <T>(type: Type<T>, value: any): Reference<T>;
/**
* Gets the value using pointer arithmetic.
*/
[index: number]: any;
/**
* Dereferences the pointer.
*/
value: any;
};
/**
* A type that is used to represent a void*.
*/
interface Pointer {
/**
* Creates a new pointer with the given offset.
* @param offset The offset in bytes.
*/
new (offset: number);
/**
* Creates a new pointer by adding an offset to the current pointer.
* @param offset The offset in bytes.
*/
add(offset: number): Pointer;
/**
* Creates a new pointer by removing an offset from the current pointer.
* @param offset The offset in bytes.
*/
subtract(offset: number): Pointer;
/**
* Converts the value of this instance to a number.
*/
toNumber(): number;
}
interface Type<T> {
(ptr: Pointer): T;
}
var types: {
"void": Type<void>;
bool: Type<boolean>;
int8: Type<number>;
uint8: Type<number>;
int16: Type<number>;
uint16: Type<number>;
int32: Type<number>;
uint32: Type<number>;
int64: Type<number>;
uint64: Type<number>;
float: Type<number>;
double: Type<number>;
//UTF8CString: Type<Reference<types.int8>>;
unichar: Type<string>;
id: Type<NSObject>;
protocol: Type<Object>;
"class": Type<NSObject>;
selector: Type<string>;
}
}
declare function __collect(): void;
You are visitor 01402520 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.